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"
40 #include "MeasurementInfoItem.h"
41 #include "E2SM-KPM-ActionDefinition-Format1.h"
42 #include "E2SM-KPM-ActionDefinition.h"
43 #include "E2SM-KPM-EventTriggerDefinition-Format1.h"
44 #include "E2SM-KPM-EventTriggerDefinition.h"
47 /*******************************************************************
49 * @brief Assigns new transaction id to RIC initiated procedure
53 * Function : assignTransactionId
55 * Functionality: Assigns new transaction id to a RIC initiated
58 * @params[in] Region region
60 * @return ROK - success
63 * ****************************************************************/
65 uint8_t assignTransactionId(DuDb *duDb)
67 uint8_t currTransId = duDb->ricTransIdCounter;
69 /* Update to next valid value */
70 duDb->ricTransIdCounter++;
71 if(duDb->ricTransIdCounter == MAX_NUM_TRANSACTION)
72 duDb->ricTransIdCounter = 0;
77 /*******************************************************************
79 * @brief Sends E2 msg over SCTP
83 * Function : SendE2APMsg
85 * Functionality: Sends E2 msg over SCTP
87 * @params[in] Region region
89 * @return ROK - success
92 * ****************************************************************/
94 uint8_t SendE2APMsg(Region region, Pool pool, uint32_t duId)
98 if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
100 if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
102 ODU_PRINT_MSG(mBuf, 0,0);
104 if(sctpSend(duId, mBuf) != ROK)
106 DU_LOG("\nERROR --> E2AP : SCTP Send for E2 failed");
107 ODU_PUT_MSG_BUF(mBuf);
113 DU_LOG("\nERROR --> E2AP : ODU_ADD_POST_MSG_MULT failed");
114 ODU_PUT_MSG_BUF(mBuf);
117 ODU_PUT_MSG_BUF(mBuf);
121 DU_LOG("\nERROR --> E2AP : Failed to allocate memory");
128 /*******************************************************************
130 * @brief Fetches RAN Function DB
134 * Function : fetchRanFuncFromRanFuncId
136 * Functionality: Fetches RAN function DB from E2AP DB using
139 * @params[in] RAN Function ID
140 * @return RAN Function DB
141 * NULL, in case of failure
143 * ****************************************************************/
144 RanFunction *fetchRanFuncFromRanFuncId(DuDb *duDb, uint16_t ranFuncId)
146 RanFunction *ranFuncDb = NULLP;
148 /* Fetch RAN Function DB */
149 if(duDb->ranFunction[ranFuncId-1].id == ranFuncId)
151 ranFuncDb = &duDb->ranFunction[ranFuncId-1];
155 DU_LOG("\nERROR --> DU_APP : fetchRanFuncFromRanFuncId: Invalid RAN Function ID[%d]", ranFuncId);
161 /*******************************************************************
163 * @brief Fetch subscripton DB
167 * Function : fetchSubsInfoFromRicReqId
169 * Functionality: Fetches subscription DB from RAN Function DB
170 * using RIC Request ID
172 * @params[in] RIC Request ID
174 * Pointer to RIC Subscription node to be searched
175 * @return RIC Subscription from RAN Function's subcription list
176 * NULL, in case of failure
178 * ****************************************************************/
179 RicSubscription *fetchSubsInfoFromRicReqId(RicRequestId ricReqId, RanFunction *ranFuncDb)
182 RicSubscription *ricSubscriptionInfo = NULLP;
184 for(subsIdx = 0; subsIdx < ranFuncDb->numOfSubscription; subsIdx++)
186 if((ranFuncDb->subscriptionList[subsIdx].requestId.requestorId == ricReqId.requestorId) &&
187 (ranFuncDb->subscriptionList[subsIdx].requestId.instanceId == ricReqId.instanceId))
189 ricSubscriptionInfo = &ranFuncDb->subscriptionList[subsIdx];
193 return ricSubscriptionInfo;
196 /*******************************************************************
198 * @brief Fetch Action details
202 * Function : fetchActionInfoFromActionId
204 * Functionality: Fetch action details from RIC subscription DB
207 * @params[in] Action ID
208 * RIC Subscription DB
209 * @return Action Info DB
210 * NULL, in case of failure
212 * ****************************************************************/
213 ActionInfo *fetchActionInfoFromActionId(uint8_t actionId, RicSubscription *ricSubscriptionInfo)
215 ActionInfo *actionInfoDb = NULLP;
216 if(ricSubscriptionInfo->actionSequence[actionId].actionId == actionId)
218 actionInfoDb = &ricSubscriptionInfo->actionSequence[actionId];
222 DU_LOG("\nERROR --> E2AP : fetchActionInfoFromActionId: Action Id [%d] not found in \
223 subscription info [Requestor id : %d] [Instance Id : %d]", actionId,\
224 ricSubscriptionInfo->requestId.requestorId, ricSubscriptionInfo->requestId.instanceId);
230 /*******************************************************************
232 * @brief deallocate memory allocated in E2 Node Config Update Failure
236 * Function : FreeE2ConfigUpdateFail
238 * Functionality: deallocate memory allocated in E2 Node Config Update Failure
240 * @params[in] E2AP_PDU_t *e2apMsg
243 * ****************************************************************/
245 void FreeE2ConfigUpdateFail(E2AP_PDU_t *e2apMsg)
248 E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail=NULL;
252 if(e2apMsg->choice.unsuccessfulOutcome)
254 e2NodeCfgUpdFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure;
255 if(e2NodeCfgUpdFail->protocolIEs.list.array)
257 for(arrIdx=0; arrIdx<e2NodeCfgUpdFail->protocolIEs.list.count; arrIdx++)
259 RIC_FREE(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateFailure_IEs_t));
261 RIC_FREE(e2NodeCfgUpdFail->protocolIEs.list.array, e2NodeCfgUpdFail->protocolIEs.list.size);
263 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
265 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
269 /*******************************************************************
271 * @brief Buld and send the E2 Node Config Update failure
275 * Function : BuildAndSendE2NodeConfigUpdateFailure
278 * - Buld and send the E2 Node Config Update failure
279 * @return ROK - success
282 * ****************************************************************/
284 uint8_t BuildAndSendE2NodeConfigUpdateFailure(uint32_t duId, uint8_t transId, uint8_t causeInfo, uint8_t causeReason)
286 E2AP_PDU_t *e2apMsg = NULL;
287 asn_enc_rval_t encRetVal;
289 uint8_t elementCnt=0;
290 bool memAllocFailed = false;
291 E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdateFail=NULL;
293 DU_LOG("\nINFO --> E2AP : Building E2 Node Config Update failure\n");
296 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
299 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
302 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
303 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
304 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
306 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
310 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
311 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
312 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure;
313 e2NodeCfgUpdateFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure;
316 e2NodeCfgUpdateFail->protocolIEs.list.count = elementCnt;
317 e2NodeCfgUpdateFail->protocolIEs.list.size = elementCnt * sizeof(struct E2nodeConfigurationUpdateFailure_IEs *);
319 RIC_ALLOC(e2NodeCfgUpdateFail->protocolIEs.list.array, e2NodeCfgUpdateFail->protocolIEs.list.size);
320 if(e2NodeCfgUpdateFail->protocolIEs.list.array == NULLP)
322 DU_LOG("\nERROR --> E2AP : Memory allocation for E2 node config update failure array failed");
326 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
328 RIC_ALLOC(e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx], sizeof(struct E2nodeConfigurationUpdateFailure_IEs));
329 if(e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx] == NULLP)
331 DU_LOG("\nERROR --> E2AP : Memory allocation for E2 node config update failure IEs failed");
332 memAllocFailed = true;
337 if(memAllocFailed == true)
344 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
345 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
346 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID;
347 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
350 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
351 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
352 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2;
353 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = causeInfo;
354 if(causeInfo == CauseE2_PR_e2Node)
355 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.e2Node = causeReason;
357 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.misc = causeReason;
360 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
361 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
362 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2;
363 e2NodeCfgUpdateFail->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
365 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
366 memset(encBuf, 0, ENC_BUF_MAX_LEN);
368 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
370 /* Check encode results */
371 if(encRetVal.encoded == ENCODE_FAIL)
373 DU_LOG("\nERROR --> E2AP : Could not encode E2 Node Config Update failure structure (at %s)\n",\
374 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
379 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node Config Update Failure\n");
380 for(int i=0; i< encBufSize; i++)
382 DU_LOG("%x",encBuf[i]);
386 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
388 DU_LOG("\nERROR --> E2AP : Sending E2 Node Config Update Failure failed");
394 FreeE2ConfigUpdateFail(e2apMsg);
398 /*******************************************************************
400 * @brief process the E2 node configuration update
404 * Function : ProcE2NodeConfigUpdate
406 * Functionality: Process E2 node configuration update
408 * @return ROK - success
411 ******************************************************************/
413 void ProcE2NodeConfigUpdate(uint32_t duId, E2nodeConfigurationUpdate_t *e2NodeConfigUpdate)
416 uint8_t transId = 0, e2NodeUpdateListIdx=0;
417 E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList=NULLP;
418 E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItemIe=NULLP;
419 E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULLP;
421 if(e2NodeConfigUpdate)
423 if(e2NodeConfigUpdate->protocolIEs.list.array)
425 for(ieIdx=0; ieIdx < e2NodeConfigUpdate->protocolIEs.list.count; ieIdx++)
427 if(e2NodeConfigUpdate->protocolIEs.list.array[ieIdx])
429 switch(e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->id)
431 case ProtocolIE_IDE2_id_TransactionID:
432 transId = e2NodeConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
437 /*TODO - Other IEs will be handling in next gerrit*/
447 /*******************************************************************
449 * @brief Builds Global RIC Id Params
453 * Function : BuildGlobalRicId
455 * Functionality: Building the Plmn and ric id
457 * @params[in] GlobalRIC_ID_t *ricId
458 * @return ROK - success
461 * ****************************************************************/
463 uint8_t BuildGlobalRicId(GlobalRIC_ID_t *ricId)
466 uint8_t byteSize = 3;
470 ricId->pLMN_Identity.size = byteSize * sizeof(uint8_t);
471 RIC_ALLOC(ricId->pLMN_Identity.buf, ricId->pLMN_Identity.size);
472 buildPlmnId(ricCb.ricCfgParams.plmn , ricId->pLMN_Identity.buf);
474 ricId->ric_ID.size = byteSize * sizeof(uint8_t);
475 RIC_ALLOC(ricId->ric_ID.buf, ricId->ric_ID.size);
476 fillBitString(&ricId->ric_ID, unused, byteSize, ricVal);
481 /*******************************************************************
483 * @brief deallocate the memory allocated in E2SetupResponse
487 * Function : FreeE2SetupRsp
489 * Functionality: deallocate the memory allocated in E2SetupResponse
491 * @params[in] E2AP_PDU_t *e2apMsg
494 * ****************************************************************/
495 void FreeE2SetupRsp(E2AP_PDU_t *e2apMsg)
497 uint8_t arrIdx = 0, e2NodeConfigIdx=0, ranFuncIdx=0;
498 RANfunctionsID_List_t *ranFuncAcceptedList=NULL;
499 E2setupResponse_t *e2SetupRsp=NULL;
500 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItemIe=NULL;
501 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList=NULL;
502 E2nodeComponentInterfaceF1_t *f1InterfaceInfo=NULL;
506 if(e2apMsg->choice.successfulOutcome)
508 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
509 if(e2SetupRsp->protocolIEs.list.array)
511 for(arrIdx=0; arrIdx<e2SetupRsp->protocolIEs.list.count; arrIdx++)
513 switch(e2SetupRsp->protocolIEs.list.array[arrIdx]->id)
515 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
517 ranFuncAcceptedList= &e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
518 if(ranFuncAcceptedList->list.array)
520 for(ranFuncIdx=0;ranFuncIdx<ranFuncAcceptedList->list.count; ranFuncIdx++)
522 if(ranFuncAcceptedList->list.array[ranFuncIdx])
524 RIC_FREE(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
527 RIC_FREE(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
531 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
533 e2NodeConfigAdditionAckList =&e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
534 if(e2NodeConfigAdditionAckList->list.count)
536 for(e2NodeConfigIdx=0; e2NodeConfigIdx<e2NodeConfigAdditionAckList->list.count; e2NodeConfigIdx++)
538 e2NodeAddAckItemIe = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[e2NodeConfigIdx];
539 if(e2NodeAddAckItemIe)
541 f1InterfaceInfo = e2NodeAddAckItemIe->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
544 RIC_FREE(f1InterfaceInfo->gNB_DU_ID.buf, f1InterfaceInfo->gNB_DU_ID.size);
545 RIC_FREE(f1InterfaceInfo, sizeof(E2nodeComponentInterfaceF1_t));
547 RIC_FREE(e2NodeAddAckItemIe, sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
550 RIC_FREE(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
555 RIC_FREE(e2SetupRsp->protocolIEs.list.array[arrIdx], sizeof(E2setupResponseIEs_t));
557 RIC_FREE(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
559 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
561 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
565 /*******************************************************************
567 * @brief Build E2node Component config addition ack list
571 * Function : BuildE2nodeComponentConfigAdditionAck
573 * Functionality: deallocate the memory allocated in E2SetupResponse
575 * @params[in] E2nodeComponentConfigAdditionAck_List_t
576 * *e2NodeConfigAdditionAckList
578 * @return ROK - success
580 * ****************************************************************/
582 uint8_t BuildE2nodeComponentConfigAdditionAck(E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList, DuDb *duDb)
585 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem;
587 e2NodeConfigAdditionAckList->list.count = 1;
588 e2NodeConfigAdditionAckList->list.size = e2NodeConfigAdditionAckList->list.count * sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t*);
589 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
590 if(e2NodeConfigAdditionAckList->list.array == NULLP)
592 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
596 for(arrIdx = 0; arrIdx< e2NodeConfigAdditionAckList->list.count; arrIdx++)
598 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
599 if(e2NodeConfigAdditionAckList->list.array[arrIdx] == NULLP)
601 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
605 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[0];
606 e2NodeAddAckItem->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck_Item;
607 e2NodeAddAckItem->criticality = CriticalityE2_reject;
608 e2NodeAddAckItem->value.present = E2nodeComponentConfigAdditionAck_ItemIEs__value_PR_E2nodeComponentConfigAdditionAck_Item;
609 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentInterfaceType = duDb->e2NodeComponent.interfaceType;
611 /* >E2 Node Component ID */
612 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
613 RIC_ALLOC(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
614 sizeof(E2nodeComponentInterfaceF1_t));
615 if(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1 == NULLP)
617 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
620 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
621 RIC_ALLOC(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
622 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
624 if(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
626 DU_LOG("\nERROR -->list. E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
629 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0] = duDb->e2NodeComponent.componentId;
631 /* >E2 Node Component Configuration Acknowledge*/
632 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentConfigurationAck.updateOutcome = \
633 E2nodeComponentConfigurationAck__updateOutcome_success;
638 /*******************************************************************
640 * @brief Build RAN function accepted list
644 * Function : BuildRanFunctionAcceptedList
646 * Functionality: Build RAN function accepted list
647 * ->For ProcedureCodeE2_id_E2setup or ProcedureCodeE2_id_RICserviceQuery
648 * we add all the RAN Function list which is present in RIC database.
649 * ->For any other procedures, we just fill the RAN functions whose ID
650 * is present in the recvList
654 * Count of ran functions to be accepted in the list
655 * Received list of RAN functions
659 * @return ROK - success
661 * ****************************************************************/
663 uint8_t BuildRanFunctionAcceptedList(DuDb *duDb, uint8_t count, RanFunction *ranFunAcceptedList, RANfunctionsID_List_t *ranFuncAcceptedList, uint8_t procedureCode)
665 uint8_t ranFuncIdx = 0;
666 RANfunctionID_ItemIEs_t *ranFuncAcceptedItemIe=NULL;
668 /* For ProcedureCodeE2_id_E2setup and ProcedureCodeE2_id_RICserviceQuery,
669 * the number of RAN function list items is equal to the number of
670 * ran function entries stored in the database.
671 * For any other procedure, the RAN function list count is equal
672 * to the count of ran functions obtained from the function's caller */
674 if((procedureCode == ProcedureCodeE2_id_RICserviceQuery)||(procedureCode == ProcedureCodeE2_id_E2setup))
675 ranFuncAcceptedList->list.count = duDb->numOfRanFunction;
677 ranFuncAcceptedList->list.count = count;
679 ranFuncAcceptedList->list.size = ranFuncAcceptedList->list.count*sizeof(RANfunctionID_ItemIEs_t*);
680 RIC_ALLOC(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
681 if(ranFuncAcceptedList->list.array)
683 for(ranFuncIdx = 0; ranFuncIdx< ranFuncAcceptedList->list.count; ranFuncIdx++)
685 RIC_ALLOC(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
686 if(ranFuncAcceptedList->list.array[ranFuncIdx] == NULLP)
688 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array item");
691 ranFuncAcceptedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAcceptedList->list.array[ranFuncIdx];
692 ranFuncAcceptedItemIe->id = ProtocolIE_IDE2_id_RANfunctionID_Item;
693 ranFuncAcceptedItemIe->criticality= CriticalityE2_ignore;
694 ranFuncAcceptedItemIe->value.present = RANfunctionID_ItemIEs__value_PR_RANfunctionID_Item;
695 if((procedureCode == ProcedureCodeE2_id_RICserviceQuery)||(procedureCode == ProcedureCodeE2_id_E2setup))
697 /* filling the RAN function information with the help of DuDb */
698 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID = duDb->ranFunction[ranFuncIdx].id;
699 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision= duDb->ranFunction[ranFuncIdx].revisionCounter;
703 /* filling the the RAN function information with the help received list of RAN functions */
704 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID = ranFunAcceptedList[ranFuncIdx].id;
705 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision= ranFunAcceptedList[ranFuncIdx].revisionCounter;
711 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array");
717 /*******************************************************************
719 * @brief Builds and sends the E2SetupResponse
723 * Function : BuildAndSendE2SetupRsp
725 * Functionality: Constructs the F1SetupResponse message and sends
726 * it back to the DU through SCTP.
728 * @params[in] void **buf,Buffer to which encoded pattern is written into
729 * @params[in] int *size,size of buffer
731 * @return ROK - success
734 * ****************************************************************/
736 uint8_t BuildAndSendE2SetupRsp(DuDb *duDb, uint8_t transId)
738 E2AP_PDU_t *e2apMsg = NULL;
739 E2setupResponse_t *e2SetupRsp;
740 asn_enc_rval_t encRetVal;
743 bool memAllocFailed = false;
745 DU_LOG("\nINFO --> E2AP : Building E2 Setup Response\n");
748 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
751 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
754 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
755 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
756 if(e2apMsg->choice.successfulOutcome == NULLP)
758 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
762 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
763 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
764 e2apMsg->choice.successfulOutcome->value.present = \
765 SuccessfulOutcomeE2__value_PR_E2setupResponse;
766 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
769 /* Fill Accepted RAN function IE If Ran function information is stored in databse */
770 if(duDb->numOfRanFunction)
773 e2SetupRsp->protocolIEs.list.count = elementCnt;
774 e2SetupRsp->protocolIEs.list.size = elementCnt * sizeof(E2setupResponseIEs_t*);
776 RIC_ALLOC(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
777 if(e2SetupRsp->protocolIEs.list.array == NULLP)
779 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
783 for(idx=0; idx<elementCnt; idx++)
785 RIC_ALLOC(e2SetupRsp->protocolIEs.list.array[idx], sizeof(E2setupResponseIEs_t));
786 if(e2SetupRsp->protocolIEs.list.array[idx] == NULLP)
788 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
789 memAllocFailed = true;
794 if(memAllocFailed == true)
796 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
801 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_TransactionID;
802 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
803 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_TransactionID;
804 e2SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID = transId;
808 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_GlobalRIC_ID;
809 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
810 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_GlobalRIC_ID;
812 if(BuildGlobalRicId(&(e2SetupRsp->protocolIEs.list.array[idx]->value.choice.GlobalRIC_ID))!=ROK)
814 DU_LOG("\nERROR --> E2AP : Failed to build Global Ric Id");
818 if(duDb->numOfRanFunction)
820 /* Accepted RAN function Id */
822 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
823 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
824 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_RANfunctionsID_List;
825 if(BuildRanFunctionAcceptedList(duDb, 0, NULL, &e2SetupRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_E2setup)!=ROK)
827 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
832 /* E2 Node Component Configuration Addition Acknowledge List*/
834 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck;
835 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
836 e2SetupRsp->protocolIEs.list.array[idx]->value.present = \
837 E2setupResponseIEs__value_PR_E2nodeComponentConfigAdditionAck_List;
838 if(BuildE2nodeComponentConfigAdditionAck(&e2SetupRsp->protocolIEs.list.array[idx]->\
839 value.choice.E2nodeComponentConfigAdditionAck_List, duDb) != ROK)
841 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config addition ack list");
845 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
846 memset(encBuf, 0, ENC_BUF_MAX_LEN);
848 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
850 /* Check encode results */
851 if(encRetVal.encoded == ENCODE_FAIL)
853 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupResponse structure (at %s)\n",\
854 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
859 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupResponse\n");
860 for(int i=0; i< encBufSize; i++)
862 DU_LOG("%x",encBuf[i]);
866 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
868 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Response failed");
874 FreeE2SetupRsp(e2apMsg);
875 BuildAndSendRicSubscriptionReq(duDb);
879 /*******************************************************************
881 * @brief Free RIC Subscription Details
885 * Function : FreeRicSubsDetails
887 * Functionality: Free the RIC Subscription Details
889 * @params[in] RICsubscriptionDetails_t *subsDetails
892 * ****************************************************************/
893 void FreeRicSubsDetails(RICsubscriptionDetails_t *subsDetails)
895 uint8_t elementIdx = 0;
896 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
898 RIC_FREE(subsDetails->ricEventTriggerDefinition.buf, subsDetails->ricEventTriggerDefinition.size);
900 if(subsDetails->ricAction_ToBeSetup_List.list.array)
902 for(elementIdx = 0; elementIdx < subsDetails->ricAction_ToBeSetup_List.list.count; elementIdx++)
904 if(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
906 actionItem = (RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx];
907 if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
909 RIC_FREE(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf, \
910 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->size);
911 RIC_FREE(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
913 RIC_FREE(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], sizeof(RICaction_ToBeSetup_ItemIEs_t))
916 RIC_FREE(subsDetails->ricAction_ToBeSetup_List.list.array, subsDetails->ricAction_ToBeSetup_List.list.size);
920 /*******************************************************************
922 * @brief Free RIC Subscription Request
926 * Function : FreeRicSubscriptionReq
928 * Functionality : Free RIC Subscription Request
930 * @return ROK - success
933 ******************************************************************/
934 void FreeRicSubscriptionReq(E2AP_PDU_t *e2apRicMsg)
937 RICsubscriptionRequest_t *ricSubscriptionReq;
941 if(e2apRicMsg->choice.initiatingMessage)
943 ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
944 if(ricSubscriptionReq->protocolIEs.list.array)
946 for(idx=0; idx < ricSubscriptionReq->protocolIEs.list.count; idx++)
948 switch(ricSubscriptionReq->protocolIEs.list.array[idx]->id)
950 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
952 FreeRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails));
956 RIC_FREE(ricSubscriptionReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionRequest_IEs_t));
958 RIC_FREE(ricSubscriptionReq->protocolIEs.list.array, ricSubscriptionReq->protocolIEs.list.size);
960 RIC_FREE(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
962 RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
966 /*******************************************************************
968 * @brief Builds Ric Request Id
972 * Function : BuildNewRicRequestId
974 * Functionality: Assign new Ric Request ID
976 * @params[in] RIC request ID to be sent
977 * RIC request ID stored in DB
978 * @return ROK - success
981 * ****************************************************************/
983 uint8_t BuildNewRicRequestId(RICrequestID_t *ricReqId, RicRequestId *reqIdDb)
985 static uint16_t requestorId = 0;
986 static uint16_t instanceId = 0;
988 if(ricReqId != NULLP)
990 ricReqId->ricRequestorID = ++requestorId;
991 ricReqId->ricInstanceID = ++instanceId;
993 reqIdDb->requestorId = ricReqId->ricRequestorID;
994 reqIdDb->instanceId = ricReqId->ricInstanceID;
999 /*******************************************************************
1001 * @brief Free RIC Action Definition
1005 * Function : FreeRicActionDefinition
1007 * Functionality: Free RIC Action Definition
1009 * @params[in] E2SM-KPM Action definition
1012 * ****************************************************************/
1013 void FreeRicActionDefinition(E2SM_KPM_ActionDefinition_t actionDef)
1015 uint8_t elementIdx = 0;
1016 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
1017 MeasurementInfoItem_t *measItem = NULLP;
1019 switch(actionDef.actionDefinition_formats.present)
1021 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
1023 if(actionDef.actionDefinition_formats.choice.actionDefinition_Format1)
1025 actionFormat1 = actionDef.actionDefinition_formats.choice.actionDefinition_Format1;
1026 if(actionFormat1->measInfoList.list.array)
1028 for(elementIdx = 0; elementIdx < actionFormat1->measInfoList.list.count; elementIdx++)
1030 if(actionFormat1->measInfoList.list.array[elementIdx])
1032 measItem = actionFormat1->measInfoList.list.array[elementIdx];
1033 switch(measItem->measType.present)
1035 case MeasurementType_PR_NOTHING:
1036 case MeasurementType_PR_measID:
1038 case MeasurementType_PR_measName:
1040 RIC_FREE(measItem->measType.choice.measName.buf, measItem->measType.choice.measName.size)
1044 RIC_FREE(measItem, sizeof(MeasurementInfoItem_t));
1047 RIC_FREE(actionFormat1->measInfoList.list.array, actionFormat1->measInfoList.list.size);
1049 RIC_FREE(actionFormat1, sizeof(E2SM_KPM_ActionDefinition_Format1_t));
1054 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format2:
1055 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format3:
1056 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format4:
1057 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format5:
1058 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_NOTHING:
1063 /*******************************************************************
1065 * @brief Fill RIC Action Definition
1069 * Function : fillRicActionDef
1071 * Functionality: Fill RIC Action Definition
1073 * @params[in] RIC Action definition
1077 * ****************************************************************/
1078 uint8_t fillRicActionDef(RICactionDefinition_t *ricActionDef)
1080 uint8_t ret = RFAILED;
1081 asn_enc_rval_t encRetVal;
1082 uint8_t elementCnt = 0, elementIdx = 0;
1083 char *measurementTypeName[] = {"RRU.PrbTotDl", "RRU.PrbTotUl"};
1084 E2SM_KPM_ActionDefinition_t actionDef;
1085 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
1086 MeasurementInfoItem_t *measItem = NULLP;
1090 /* Fill E2SM-KPM Action Definition Format 1 */
1092 /* RIC Stype Type */
1093 actionDef.ric_Style_Type = RIC_STYLE_TYPE;
1095 /* RIC Action Definition Format 1 */
1096 actionDef.actionDefinition_formats.present = \
1097 E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1;
1099 RIC_ALLOC(actionDef.actionDefinition_formats.choice.actionDefinition_Format1, \
1100 sizeof(E2SM_KPM_ActionDefinition_Format1_t));
1101 if(actionDef.actionDefinition_formats.choice.actionDefinition_Format1 == NULLP)
1103 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1106 actionFormat1 = actionDef.actionDefinition_formats.choice.actionDefinition_Format1;
1108 /* Measurement Info List */
1110 actionFormat1->measInfoList.list.count = elementCnt;
1111 actionFormat1->measInfoList.list.size = elementCnt * sizeof(MeasurementInfoItem_t *);
1112 RIC_ALLOC(actionFormat1->measInfoList.list.array, actionFormat1->measInfoList.list.size);
1113 if(actionFormat1->measInfoList.list.array == NULL)
1115 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1119 for(elementIdx = 0; elementIdx < elementCnt; elementIdx++)
1121 RIC_ALLOC(actionFormat1->measInfoList.list.array[elementIdx], sizeof(MeasurementInfoItem_t));
1122 if(actionFormat1->measInfoList.list.array[elementIdx] == NULLP)
1124 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1128 measItem = actionFormat1->measInfoList.list.array[elementIdx];
1129 measItem->measType.present = MeasurementType_PR_measName;
1131 measItem->measType.choice.measName.size = strlen(measurementTypeName[elementIdx]);
1132 RIC_ALLOC(measItem->measType.choice.measName.buf, measItem->measType.choice.measName.size);
1133 if(measItem->measType.choice.measName.buf == NULLP)
1135 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1138 memcpy(measItem->measType.choice.measName.buf, measurementTypeName[elementIdx], measItem->measType.choice.measName.size);
1140 if(elementIdx < elementCnt)
1143 /* Granularity Period */
1144 actionFormat1->granulPeriod = RIC_ACTION_GRANULARITY_PERIOD; /* In ms */
1146 /* Prints the Msg formed */
1147 xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, &actionDef);
1149 /* Encode E2SM-KPM RIC Action Definition */
1150 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1152 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_ActionDefinition, 0, &actionDef, PrepFinalEncBuf, encBuf);
1153 if(encRetVal.encoded == ENCODE_FAIL)
1155 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM action definition structure (at %s)\n",\
1156 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1160 /* Copty encoded E2SM-KPM RIC action definition to E2AP octet string buffer */
1161 ricActionDef->size = encBufSize;
1162 RIC_ALLOC(ricActionDef->buf, encBufSize);
1163 if(ricActionDef->buf == NULLP)
1165 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1168 memcpy(ricActionDef->buf, encBuf, encBufSize);
1174 FreeRicActionDefinition(actionDef);
1178 /*******************************************************************
1180 * @brief Fills RIC Action To Be Setup Item
1184 * Function : fillActionToBeSetup
1186 * Functionality: Fill the RIC Action To Be Setup Ite,
1187 * RIC subscription DB
1189 * @params[in] RICaction_ToBeSetup_ItemIEs_t *items
1190 * @return ROK - success
1193 * ****************************************************************/
1194 uint8_t fillActionToBeSetup(RICaction_ToBeSetup_ItemIEs_t *actionItem, RicSubscription *ricSubsDb)
1196 static uint8_t ricActionId = 0;
1198 if(actionItem == NULLP)
1200 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
1206 actionItem->id = ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item;
1207 actionItem->criticality = CriticalityE2_ignore;
1208 actionItem->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
1211 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID = ricActionId;
1212 ricSubsDb->actionSequence[ricActionId].actionId = \
1213 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID;
1216 /* RIC Action Type */
1217 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType = RICactionType_report;
1219 /* RIC Action Definition */
1220 RIC_ALLOC(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
1221 if(!actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
1223 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1226 if(fillRicActionDef(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition) != ROK)
1228 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
1232 ricSubsDb->numOfActions++;
1236 memset(&ricSubsDb->actionSequence[ricActionId], 0, sizeof(ActionInfo));
1237 ricSubsDb->actionSequence[ricActionId].actionId = -1;
1241 /*******************************************************************
1243 * @brief Free Event Trigger Definition
1247 * Function : FreeEventTriggerDef
1249 * Functionality: Free Event Trigger Definition
1251 * @params[in] E2SM-KPM Event Trigger Definition
1254 * ****************************************************************/
1255 void FreeEventTriggerDef(E2SM_KPM_EventTriggerDefinition_t *eventTiggerDef)
1259 switch(eventTiggerDef->eventDefinition_formats.present)
1261 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING:
1263 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1:
1264 RIC_FREE(eventTiggerDef->eventDefinition_formats.choice.eventDefinition_Format1, \
1265 sizeof(E2SM_KPM_EventTriggerDefinition_Format1_t));
1271 /*******************************************************************
1273 * @brief Fill Event Trigger Definition
1277 * Function : fillEventTriggerDef
1279 * Functionality: Fill Event Trigger Definition
1281 * @params[in] RIC Event Trigger Definition
1285 * ****************************************************************/
1286 uint8_t fillEventTriggerDef(RICeventTriggerDefinition_t *ricEventTriggerDef)
1288 uint8_t ret = RFAILED;
1289 asn_enc_rval_t encRetVal;
1290 E2SM_KPM_EventTriggerDefinition_t eventTiggerDef;
1294 /* Fill E2SM-KPM Event Trigger Definition Format 1 */
1295 eventTiggerDef.eventDefinition_formats.present = \
1296 E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1;
1298 RIC_ALLOC(eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1, \
1299 sizeof(E2SM_KPM_EventTriggerDefinition_Format1_t));
1300 if(eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1 == NULLP)
1302 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1306 eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1->reportingPeriod = 1000; /* In ms */
1308 /* Prints the Msg formed */
1309 xer_fprint(stdout, &asn_DEF_E2SM_KPM_EventTriggerDefinition, &eventTiggerDef);
1311 /* Encode E2SM-KPM Event Trigger Definition */
1312 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1314 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_EventTriggerDefinition, 0, &eventTiggerDef, PrepFinalEncBuf, encBuf);
1315 if(encRetVal.encoded == ENCODE_FAIL)
1317 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM event trigger definition structure (at %s)\n",\
1318 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1322 /* Copy encoded E2SM-KPM event trigger definition to E2AP octet string buffer */
1323 ricEventTriggerDef->size = encBufSize;
1324 RIC_ALLOC(ricEventTriggerDef->buf, encBufSize);
1325 if(ricEventTriggerDef->buf == NULLP)
1327 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1330 memcpy(ricEventTriggerDef->buf, encBuf, encBufSize);
1336 FreeEventTriggerDef(&eventTiggerDef);
1340 /*******************************************************************
1342 * @brief builds RIC Subscription Details
1346 * Function : BuildsRicSubsDetails
1348 * Functionality: Builds the RIC Subscription Details
1350 * @params[in] RIC Subscription details to be filled
1351 * RIC subscriotion DB
1352 * @return ROK - success
1355 * ****************************************************************/
1357 uint8_t BuildRicSubsDetails(RICsubscriptionDetails_t *subsDetails, RicSubscription *ricSubsDb)
1359 uint8_t actionIdx = 0;
1360 uint8_t elementCnt = 0;
1361 uint8_t elementIdx = 0;
1363 if(subsDetails == NULLP)
1365 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
1371 /* RIC Event Trigger Definition */
1372 if(fillEventTriggerDef(&subsDetails->ricEventTriggerDefinition) != ROK)
1374 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
1378 /* RIC Actions To Be Setup List */
1380 subsDetails->ricAction_ToBeSetup_List.list.count = elementCnt;
1381 subsDetails->ricAction_ToBeSetup_List.list.size = elementCnt * sizeof(RICaction_ToBeSetup_ItemIEs_t *);
1382 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array, subsDetails->ricAction_ToBeSetup_List.list.size);
1383 if(subsDetails->ricAction_ToBeSetup_List.list.array == NULLP)
1385 DU_LOG("\nERROR --> E2AP : Memory allocation for RICactionToBeSetup Items failed");
1389 for(elementIdx = 0; elementIdx < elementCnt; elementIdx++)
1391 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], sizeof(RICaction_ToBeSetup_ItemIEs_t));
1392 if(!subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
1394 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1398 if(elementIdx < elementCnt)
1401 for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
1403 ricSubsDb->actionSequence[actionIdx].actionId = -1;
1407 if(fillActionToBeSetup((RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], \
1410 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
1419 /*******************************************************************
1421 * @brief Builds and Send the RicSubscriptionReq
1425 * Function : BuildAndSendRicSubscriptionReq
1427 * Functionality:Fills the RicSubscriptionReq
1429 * @return ROK - success
1432 ******************************************************************/
1433 uint8_t BuildAndSendRicSubscriptionReq(DuDb *duDb)
1435 uint8_t ret = RFAILED;
1436 E2AP_PDU_t *e2apRicMsg = NULL;
1437 RICsubscriptionRequest_t *ricSubscriptionReq;
1440 asn_enc_rval_t encRetVal; /* Encoder return value */
1441 RanFunction *ranFuncDb = &duDb->ranFunction[0];
1443 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Request\n");
1447 RIC_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
1448 if(e2apRicMsg == NULLP)
1450 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1454 e2apRicMsg->present = E2AP_PDU_PR_initiatingMessage;
1455 RIC_ALLOC(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1456 if(e2apRicMsg->choice.initiatingMessage == NULLP)
1458 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1461 e2apRicMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscription;
1462 e2apRicMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
1463 e2apRicMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionRequest;
1465 ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
1468 ricSubscriptionReq->protocolIEs.list.count = elementCnt;
1469 ricSubscriptionReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionRequest_IEs_t);
1471 /* Initialize the subscription members */
1472 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array, ricSubscriptionReq->protocolIEs.list.size);
1473 if(ricSubscriptionReq->protocolIEs.list.array == NULLP)
1475 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1479 for(idx=0; idx<elementCnt; idx++)
1481 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionRequest_IEs_t));
1482 if(ricSubscriptionReq->protocolIEs.list.array[idx] == NULLP)
1484 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1488 if(idx < elementCnt)
1491 /* Filling RIC Request Id */
1493 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
1494 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1495 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
1496 RICsubscriptionRequest_IEs__value_PR_RICrequestID;
1497 if(BuildNewRicRequestId(&ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICrequestID, \
1498 &ranFuncDb->subscriptionList[ranFuncDb->numOfSubscription].requestId) != ROK)
1500 DU_LOG("\nERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__);
1505 /* Filling RAN Function Id */
1507 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
1508 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1509 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
1510 RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
1511 ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID = ranFuncDb->id;
1513 /* Filling RIC Subscription Details */
1515 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICsubscriptionDetails;
1516 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1517 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
1518 RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails;
1519 if(BuildRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails),\
1520 &ranFuncDb->subscriptionList[ranFuncDb->numOfSubscription]) != ROK)
1522 DU_LOG("\nERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__);
1526 /* Prints the Msg formed */
1527 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
1529 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1531 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf);
1532 if(encRetVal.encoded == ENCODE_FAIL)
1534 DU_LOG("\nERROR --> E2AP : Could not encode RicSubscriptionRequest structure (at %s)\n",\
1535 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1540 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionRequest\n");
1541 for(int i=0; i< encBufSize; i++)
1543 DU_LOG("%x",encBuf[i]);
1548 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
1550 DU_LOG("\nERROR --> E2AP : Sending RIC subscription Request failed");
1554 ranFuncDb->numOfSubscription++;
1560 memset(&ranFuncDb->subscriptionList[ranFuncDb->numOfSubscription], 0, sizeof(RicSubscription));
1561 FreeRicSubscriptionReq(e2apRicMsg);
1565 /*******************************************************************
1567 * @brief Process RicSubscriptionResponse
1571 * Function : ProcRicSubscriptionRsp
1573 * Functionality: Processes RicSubscriptionRsp
1575 * @return ROK - void
1577 ******************************************************************/
1579 void ProcRicSubscriptionResponse(uint32_t duId, RICsubscriptionResponse_t *ricSubscriptionRsp)
1581 uint8_t duIdx = 0, ieIdx = 0, notAdmitIdx = 0;
1582 uint8_t ranFuncId = 0, actionId = 0;
1584 bool ricReqIdDecoded = false;
1585 RicRequestId ricReqId;
1586 RanFunction *ranFuncDb = NULLP;
1587 RicSubscription *ricSubs = NULLP;
1588 ActionInfo *action = NULLP;
1589 RICsubscriptionResponse_IEs_t *ricSubsRspIe = NULLP;
1590 RICaction_NotAdmitted_List_t *notAdmitList = NULLP;
1592 DU_LOG("\nINFO --> E2AP : RIC Subscription Response received");
1595 SEARCH_DU_DB(duIdx, duId, duDb);
1598 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
1602 memset(&ricReqId, 0, sizeof(RicRequestId));
1603 if(ricSubscriptionRsp)
1605 if(ricSubscriptionRsp->protocolIEs.list.array)
1607 for(ieIdx=0; ieIdx<ricSubscriptionRsp->protocolIEs.list.count; ieIdx++)
1609 if(ricSubscriptionRsp->protocolIEs.list.array[ieIdx])
1611 ricSubsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
1612 switch(ricSubscriptionRsp->protocolIEs.list.array[ieIdx]->id)
1614 case ProtocolIE_IDE2_id_RICrequestID:
1616 ricReqId.requestorId = ricSubsRspIe->value.choice.RICrequestID.ricRequestorID;
1617 ricReqId.instanceId = ricSubsRspIe->value.choice.RICrequestID.ricInstanceID;
1618 ricReqIdDecoded = true;
1621 case ProtocolIE_IDE2_id_RANfunctionID:
1623 ranFuncId = ricSubsRspIe->value.choice.RANfunctionID;
1624 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
1627 DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionResponse: RAN Function ID [%d] not found", ranFuncId);
1632 case ProtocolIE_IDE2_id_RICactions_Admitted:
1636 case ProtocolIE_IDE2_id_RICactions_NotAdmitted:
1638 if(!(ranFuncDb && ricReqIdDecoded))
1641 notAdmitList = &ricSubsRspIe->value.choice.RICaction_NotAdmitted_List;
1642 for(notAdmitIdx = 0; notAdmitIdx < notAdmitList->list.count; notAdmitIdx++)
1644 actionId = ((RICaction_NotAdmitted_ItemIEs_t *)(notAdmitList->list.array[notAdmitIdx]))->\
1645 value.choice.RICaction_NotAdmitted_Item.ricActionID;
1647 /* Remove action from RAN Function's subscription list */
1648 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb);
1651 action = fetchActionInfoFromActionId(actionId, ricSubs);
1654 memset(action, 0, sizeof(ActionInfo));
1655 ricSubs->actionSequence[actionId].actionId = -1;
1656 ricSubs->numOfActions--;
1669 /*******************************************************************
1671 * @brief deallocate the memory allocated in E2SetupFailure
1675 * Function : FreeE2SetupFailure
1677 * Functionality: deallocate the memory allocated in E2SetupFailure
1679 * @params[in] E2AP_PDU_t *e2apMsg
1682 * ****************************************************************/
1683 void FreeE2SetupFailure(E2AP_PDU_t *e2apMsg)
1686 E2setupFailure_t *e2SetupFail;
1690 if(e2apMsg->choice.unsuccessfulOutcome)
1692 e2SetupFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
1693 if(e2SetupFail->protocolIEs.list.array)
1695 for(arrIdx=0; arrIdx<e2SetupFail->protocolIEs.list.count; arrIdx++)
1697 RIC_FREE(e2SetupFail->protocolIEs.list.array[arrIdx], sizeof(E2setupFailureIEs_t));
1699 RIC_FREE(e2SetupFail->protocolIEs.list.array, e2SetupFail->protocolIEs.list.size);
1701 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
1703 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1707 /*******************************************************************
1709 * @brief Buld and send the E2 Setup failure
1713 * Function : BuildAndSendE2SetupFailure
1716 * - Buld and send the E2 Setup failure
1717 * @return ROK - success
1720 * ****************************************************************/
1722 uint8_t BuildAndSendE2SetupFailure(uint32_t duId, uint8_t transId)
1724 uint8_t ret = RFAILED;
1725 E2AP_PDU_t *e2apMsg = NULL;
1726 E2setupFailure_t *e2SetupFailure;
1727 asn_enc_rval_t encRetVal;
1730 bool memAllocFailed = false;
1732 DU_LOG("\nINFO --> E2AP : Building E2 Setup failure\n");
1735 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1736 if(e2apMsg == NULLP)
1738 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1741 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
1742 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
1743 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
1745 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1749 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
1750 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
1751 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2setupFailure;
1752 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
1755 e2SetupFailure->protocolIEs.list.count = elementCnt;
1756 e2SetupFailure->protocolIEs.list.size = elementCnt * sizeof(struct E2setupFailureIEs *);
1758 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array, e2SetupFailure->protocolIEs.list.size);
1759 if(e2SetupFailure->protocolIEs.list.array == NULLP)
1761 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
1765 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
1767 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array[arrIdx], sizeof(struct E2setupFailureIEs));
1768 if(e2SetupFailure->protocolIEs.list.array[arrIdx] == NULLP)
1770 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
1771 memAllocFailed = true;
1776 if(memAllocFailed == true)
1778 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
1784 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1785 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1786 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID;
1787 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
1790 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
1791 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1792 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2;
1793 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = CauseE2_PR_protocol;
1794 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.protocol = CauseE2Protocol_unspecified;
1797 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
1798 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
1799 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2;
1800 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
1802 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1803 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1805 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
1807 /* Check encode results */
1808 if(encRetVal.encoded == ENCODE_FAIL)
1810 DU_LOG("\nERROR --> E2AP : Could not encode E2 Setup failure structure (at %s)\n",\
1811 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1816 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Setup Failure\n");
1817 for(int i=0; i< encBufSize; i++)
1819 DU_LOG("%x",encBuf[i]);
1823 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
1825 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Failure failed");
1833 FreeE2SetupFailure(e2apMsg);
1837 /*******************************************************************
1839 * @brief process the e2setup request
1843 * Function : ProcE2SetupReq
1845 * Functionality: process the e2setup request
1847 * @return ROK - success
1850 ******************************************************************/
1852 uint8_t ProcE2SetupReq(uint32_t *duId, E2setupRequest_t *e2SetupReq)
1854 uint8_t arrIdx = 0, e2NodeAddListIdx =0, duIdx = 0, transId =0, ranFuncIdx;
1856 E2nodeComponentConfigAddition_List_t *e2NodeAddList;
1857 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem;
1858 RANfunction_ItemIEs_t *ranFuncItemIe;
1859 RANfunction_Item_t *ranFunItem;
1860 RANfunctions_List_t *ranFunctionsList;
1864 if(e2SetupReq->protocolIEs.list.array)
1866 for(arrIdx=0; arrIdx<e2SetupReq->protocolIEs.list.count; arrIdx++)
1868 if(e2SetupReq->protocolIEs.list.array[arrIdx])
1870 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
1872 case ProtocolIE_IDE2_id_TransactionID:
1874 transId = e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
1877 case ProtocolIE_IDE2_id_GlobalE2node_ID:
1879 if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID)
1881 *duId =e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID->buf[0];
1883 SEARCH_DU_DB(duIdx, *duId, duDb);
1886 duDb = &ricCb.duInfo[ricCb.numDu];
1889 memset(duDb, 0, sizeof(DuDb));
1894 case ProtocolIE_IDE2_id_RANfunctionsAdded:
1896 ranFunctionsList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
1898 if(ranFunctionsList->list.array)
1900 for(ranFuncIdx=0;ranFuncIdx<ranFunctionsList->list.count; ranFuncIdx++)
1902 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
1903 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
1904 duDb->ranFunction[ranFunItem->ranFunctionID-1].id = ranFunItem->ranFunctionID;
1905 duDb->ranFunction[ranFunItem->ranFunctionID-1].revisionCounter = ranFunItem->ranFunctionRevision;
1906 duDb->numOfRanFunction++;
1911 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
1913 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
1914 if(e2NodeAddList->list.array)
1916 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
1918 if(e2NodeAddList->list.array[e2NodeAddListIdx])
1921 (E2nodeComponentConfigAddition_ItemIEs_t *)e2NodeAddList->list.array[e2NodeAddListIdx];
1922 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.\
1923 choice.e2nodeComponentInterfaceTypeF1)
1925 duDb->e2NodeComponent.interfaceType = F1;
1926 duDb->e2NodeComponent.componentId = \
1927 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.\
1928 choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0];
1943 if(BuildAndSendE2SetupRsp(duDb, transId) !=ROK)
1945 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 setup response");
1950 /*******************************************************************
1952 * @brief Deallocate the memory allocated for E2 Reset Response
1956 * Function : FreeE2ResetResponse
1959 * - freeing the memory allocated for E2ResetResponse
1961 * @params[in] E2AP_PDU_t *e2apMsg
1962 * @return ROK - success
1965 * ****************************************************************/
1966 void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
1969 ResetResponseE2_t *resetResponse;
1971 if(e2apMsg != NULLP)
1973 if(e2apMsg->choice.successfulOutcome != NULLP)
1975 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
1976 if(resetResponse->protocolIEs.list.array)
1978 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
1980 if(resetResponse->protocolIEs.list.array[ieIdx])
1982 RIC_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
1985 RIC_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
1987 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1989 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1993 /*******************************************************************
1995 * @brief Buld and send the E2 Reset Response msg
1999 * Function : BuildAndSendE2ResetResponse
2002 * - Buld and send the E2 Reset Response Message
2003 * @return ROK - success
2006 * ****************************************************************/
2007 uint8_t BuildAndSendResetResponse(uint32_t duId, uint8_t transId)
2009 uint8_t ieIdx = 0, elementCnt = 0;
2010 uint8_t ret = RFAILED;
2011 E2AP_PDU_t *e2apMsg = NULLP;
2012 ResetResponseE2_t *resetResponse;
2013 asn_enc_rval_t encRetVal; /* Encoder return value */
2015 DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
2018 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2019 if(e2apMsg == NULLP)
2021 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
2024 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
2026 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2027 if(e2apMsg->choice.successfulOutcome == NULLP)
2029 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
2033 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset;
2034 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
2035 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2;
2036 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
2039 resetResponse->protocolIEs.list.count = elementCnt;
2040 resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *);
2041 RIC_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
2042 if(!resetResponse->protocolIEs.list.array)
2044 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
2048 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
2050 RIC_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
2051 if(!resetResponse->protocolIEs.list.array[ieIdx])
2053 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
2057 if(ieIdx < elementCnt)
2061 resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2062 resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
2063 resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID;
2064 resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
2066 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2068 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2070 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2071 if(encRetVal.encoded == ENCODE_FAIL)
2073 DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
2074 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2079 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
2080 for(int i=0; i< encBufSize; i++)
2082 DU_LOG("%x",encBuf[i]);
2087 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
2089 DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
2097 FreeE2ResetResponse(e2apMsg);
2101 /*******************************************************************
2103 * @brief process the E2 Reset Request
2107 * Function : ProcE2ResetReq
2109 * Functionality: Process E2 Reset Request
2111 * @return ROK - success
2114 ******************************************************************/
2116 uint8_t ProcE2ResetReq(uint32_t duId, ResetRequestE2_t *resetReq)
2119 uint8_t transId = 0, cause = 0;
2123 if(resetReq->protocolIEs.list.array)
2125 for(ieIdx=0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
2127 if(resetReq->protocolIEs.list.array[ieIdx])
2129 switch(resetReq->protocolIEs.list.array[ieIdx]->id)
2131 case ProtocolIE_IDE2_id_TransactionID:
2132 transId = resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
2134 case ProtocolIE_IDE2_id_CauseE2:
2135 DU_LOG("\nDEBUG --> E2AP : Reset reason %d", resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present);
2136 switch(resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present)
2138 case CauseE2_PR_NOTHING:
2140 case CauseE2_PR_ricRequest:
2141 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricRequest;
2143 case CauseE2_PR_ricService:
2144 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricService;
2146 case CauseE2_PR_e2Node:
2147 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.e2Node;
2149 case CauseE2_PR_transport:
2150 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.transport;
2152 case CauseE2_PR_protocol:
2153 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.protocol;
2155 case CauseE2_PR_misc:
2156 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.misc;
2159 DU_LOG("\nDEBUG --> E2AP : Reset cause %d", cause);
2166 BuildAndSendResetResponse(duId, transId);
2170 /*******************************************************************
2172 * @brief deallocate the memory allocated in building the
2173 * Service Query message
2177 * Function : FreeRicServiceQuery
2179 * Functionality: deallocate the memory allocated in building
2180 * Ric Service Query message
2182 * @params[in] E2AP_PDU_t *e2apMsg
2185 * ****************************************************************/
2187 void FreeRicServiceQuery(E2AP_PDU_t *e2apMsg)
2189 uint8_t arrIdx = 0, ranFuncIdx=0;
2190 RANfunctionsID_List_t *ranFuncAcceptedList=NULL;
2191 RICserviceQuery_t *ricServiceQuery=NULL;
2195 if(e2apMsg->choice.initiatingMessage)
2197 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
2198 if(ricServiceQuery->protocolIEs.list.array)
2200 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
2202 if(ricServiceQuery->protocolIEs.list.array[arrIdx])
2204 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
2206 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
2208 ranFuncAcceptedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
2209 if(ranFuncAcceptedList->list.array)
2211 for(ranFuncIdx=0;ranFuncIdx<ranFuncAcceptedList->list.count; ranFuncIdx++)
2213 RIC_FREE(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
2215 RIC_FREE(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
2219 case RICserviceQuery_IEs__value_PR_TransactionID:
2224 RIC_FREE(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
2227 RIC_FREE(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
2229 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2231 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2235 /*******************************************************************
2237 * @brief build and send the ric service Query
2241 * Function : BuildAndSendRicServiceQuery
2243 * Functionality: build and send the ric service Query
2244 * @return ROK - success
2245 * RFAILED - Acknowledge
2247 ******************************************************************/
2249 uint8_t BuildAndSendRicServiceQuery(DuDb *duDb)
2253 uint8_t ret = RFAILED;
2254 bool memAllocFailed = false;
2255 E2AP_PDU_t *e2apMsg = NULL;
2256 asn_enc_rval_t encRetVal;
2257 RICserviceQuery_t *ricServiceQuery;
2259 DU_LOG("\nINFO --> E2AP : Building Ric service Query\n");
2262 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2263 if(e2apMsg == NULLP)
2265 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2268 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
2269 RIC_ALLOC(e2apMsg->choice.initiatingMessage , sizeof(struct InitiatingMessageE2));
2270 if(e2apMsg->choice.initiatingMessage == NULLP)
2272 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2276 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceQuery;
2277 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
2278 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceQuery;
2279 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
2282 /* Fill Accepted RAN function IE If Ran function information is stored in databse */
2283 if(duDb->numOfRanFunction)
2286 ricServiceQuery->protocolIEs.list.count = elementCnt;
2287 ricServiceQuery->protocolIEs.list.size = elementCnt * sizeof(RICserviceQuery_IEs_t*);
2289 RIC_ALLOC(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
2290 if(ricServiceQuery->protocolIEs.list.array == NULLP)
2292 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
2296 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
2298 RIC_ALLOC(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
2299 if(ricServiceQuery->protocolIEs.list.array[arrIdx] == NULLP)
2301 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
2302 memAllocFailed = true;
2306 if(memAllocFailed == true)
2308 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
2314 ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2315 ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2316 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_TransactionID;
2317 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = assignTransactionId(duDb);
2319 if(duDb->numOfRanFunction)
2321 /* Accepted RAN function Id */
2323 ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
2324 ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2325 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_RANfunctionsID_List;
2326 if(BuildRanFunctionAcceptedList(duDb, 0, NULL, &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceQuery)!=ROK)
2328 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
2333 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2334 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2336 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2338 /* Check encode results */
2339 if(encRetVal.encoded == ENCODE_FAIL)
2341 DU_LOG("\nERROR --> E2AP : Could not encode RIC service Query structure (at %s)\n",\
2342 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2347 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service Query\n");
2348 for(int i=0; i< encBufSize; i++)
2350 DU_LOG("%x",encBuf[i]);
2354 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
2356 DU_LOG("\nERROR --> E2AP : Sending of RIC service Query failed");
2363 FreeRicServiceQuery(e2apMsg);
2367 /*******************************************************************
2369 * @brief deallocate the memory allocated in RicServiceUpdateFailure
2373 * Function : FreeRicServiceUpdateFailure
2375 * Functionality: deallocate the memory allocated in RicServiceUpdatefailure
2377 * @params[in] E2AP_PDU_t *e2apMsg
2380 * ****************************************************************/
2382 void FreeRicServiceUpdateFailure(E2AP_PDU_t *e2apMsg)
2385 RICserviceUpdateFailure_t *ricServiceUpdateFailure=NULL;
2389 if(e2apMsg->choice.unsuccessfulOutcome)
2391 ricServiceUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
2392 if(ricServiceUpdateFailure->protocolIEs.list.array)
2394 for(arrIdx=0; arrIdx<ricServiceUpdateFailure->protocolIEs.list.count; arrIdx++)
2396 RIC_FREE(ricServiceUpdateFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t));
2398 RIC_FREE(ricServiceUpdateFailure->protocolIEs.list.array, ricServiceUpdateFailure->protocolIEs.list.size);
2400 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
2402 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2406 /*******************************************************************
2408 * @brief fill E2 failure cause
2412 * Function : fillE2FailureCause
2414 * Functionality: fill E2 failure cause
2415 * @return ROK - success
2418 ******************************************************************/
2420 void fillE2FailureCause(CauseE2_t *cause, CauseE2_PR causePresent, uint8_t reason)
2422 cause->present = causePresent;
2424 switch(cause->present)
2426 case CauseE2_PR_ricRequest:
2427 cause->choice.ricRequest = reason;
2429 case CauseE2_PR_ricService:
2430 cause->choice.ricService = reason;
2432 case CauseE2_PR_e2Node:
2433 cause->choice.e2Node = reason;
2435 case CauseE2_PR_transport:
2436 cause->choice.transport = reason;
2438 case CauseE2_PR_protocol:
2439 cause->choice.protocol = reason;
2441 case CauseE2_PR_misc:
2442 cause->choice.misc = reason;
2445 cause->choice.misc = CauseE2Misc_unspecified;
2450 /*******************************************************************
2452 * @brief build and send the ric service update failure
2456 * Function : BuildAndSendRicServiceUpdateFailure
2458 * Functionality: build and send the ric service update failure
2459 * @return ROK - success
2462 ******************************************************************/
2464 uint8_t BuildAndSendRicServiceUpdateFailure(uint32_t duId, int8_t transId, CauseE2_PR causePresent, uint8_t reason)
2467 E2AP_PDU_t *e2apMsg = NULL;
2468 asn_enc_rval_t encRetVal;
2469 uint8_t ret = RFAILED;
2471 uint8_t elementCnt=0;
2472 RICserviceUpdateFailure_t *ricServiceFailure=NULL;
2474 DU_LOG("\nINFO --> E2AP : Building Ric service update failure\n");
2477 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2478 if(e2apMsg == NULLP)
2480 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2483 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
2484 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
2485 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
2487 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2491 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
2492 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
2493 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure;
2494 ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
2497 ricServiceFailure->protocolIEs.list.count = elementCnt;
2498 ricServiceFailure->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdateFailure_IEs_t *);
2500 RIC_ALLOC(ricServiceFailure->protocolIEs.list.array, ricServiceFailure->protocolIEs.list.size);
2501 if(ricServiceFailure->protocolIEs.list.array == NULLP)
2503 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
2507 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
2509 RIC_ALLOC(ricServiceFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t));
2510 if(ricServiceFailure->protocolIEs.list.array[arrIdx] == NULLP)
2512 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
2516 if(arrIdx<elementCnt)
2518 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
2524 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2525 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2526 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_TransactionID;
2527 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
2530 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
2531 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2532 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_CauseE2;
2533 fillE2FailureCause(&ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, causePresent, reason);
2536 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
2537 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
2538 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_TimeToWaitE2;
2539 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
2541 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2542 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2544 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2546 /* Check encode results */
2547 if(encRetVal.encoded == ENCODE_FAIL)
2549 DU_LOG("\nERROR --> E2AP : Could not encode RIC service update failure structure (at %s)\n",\
2550 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2555 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Failure\n");
2556 for(int i=0; i< encBufSize; i++)
2558 DU_LOG("%x",encBuf[i]);
2562 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
2564 DU_LOG("\nERROR --> E2AP : Sending RIC service update failed");
2571 FreeRicServiceUpdateFailure(e2apMsg);
2576 /*******************************************************************
2578 * @brief deallocate the memory allocated in RicServiceUpdateAck(
2582 * Function : FreeRicServiceUpdateAck
2584 * Functionality: deallocate the memory allocated in RicServiceUpdateAck
2586 * @params[in] E2AP_PDU_t *e2apMsg
2589 * ****************************************************************/
2591 void FreeRicServiceUpdateAck(E2AP_PDU_t *e2apMsg)
2593 uint8_t arrIdx = 0, ranFuncIdx=0;
2594 RANfunctionsID_List_t *acceptedList=NULL;
2595 RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL;
2596 RANfunctionsIDcause_List_t *rejectedList=NULL;
2600 if(e2apMsg->choice.successfulOutcome)
2602 ricServiceUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
2603 if(ricServiceUpdateAck->protocolIEs.list.array)
2605 for(arrIdx=0; arrIdx<ricServiceUpdateAck->protocolIEs.list.count; arrIdx++)
2607 if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx])
2609 switch(ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id)
2611 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
2613 acceptedList= &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
2614 if(acceptedList->list.array)
2616 for(ranFuncIdx=0;ranFuncIdx<acceptedList->list.count; ranFuncIdx++)
2618 RIC_FREE(acceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
2620 RIC_FREE(acceptedList->list.array, acceptedList->list.size);
2625 case ProtocolIE_IDE2_id_RANfunctionsRejected:
2627 rejectedList= &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
2628 if(rejectedList->list.array)
2630 for(ranFuncIdx=0;ranFuncIdx<rejectedList->list.count; ranFuncIdx++)
2632 RIC_FREE(rejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t));
2634 RIC_FREE(rejectedList->list.array, rejectedList->list.size);
2639 RIC_FREE(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t));
2642 RIC_FREE(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size);
2644 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2646 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2650 /*******************************************************************
2652 * @brief Build RAN function rejected list
2656 * Function : BuildRanFunctionRejectedList
2658 * Functionality: Build RAN function rejected list
2661 * Count of ran functions to be rejected in the list
2662 * Received list of RAN functions
2664 * @return ROK - success
2666 * ****************************************************************/
2668 uint8_t BuildRanFunctionRejectedList(uint8_t count, RanFunction *ranFunRejectedList, RANfunctionsIDcause_List_t *ranFuncRejectedList)
2670 uint8_t ranFuncIdx = 0;
2671 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
2673 ranFuncRejectedList->list.count = count;
2675 ranFuncRejectedList->list.size = ranFuncRejectedList->list.count*sizeof(RANfunctionIDcause_ItemIEs_t*);
2676 RIC_ALLOC(ranFuncRejectedList->list.array, ranFuncRejectedList->list.size);
2677 if(ranFuncRejectedList->list.array == NULLP)
2679 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array");
2683 for(ranFuncIdx = 0; ranFuncIdx< ranFuncRejectedList->list.count; ranFuncIdx++)
2685 RIC_ALLOC(ranFuncRejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t));
2686 if(ranFuncRejectedList->list.array[ranFuncIdx] == NULLP)
2688 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array item");
2691 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)ranFuncRejectedList->list.array[ranFuncIdx];
2692 ranFuncRejectedItemIe->id = ProtocolIE_IDE2_id_RANfunctionIEcause_Item;
2693 ranFuncRejectedItemIe->criticality= CriticalityE2_ignore;
2694 ranFuncRejectedItemIe->value.present = RANfunctionIDcause_ItemIEs__value_PR_RANfunctionIDcause_Item;
2695 ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID = ranFunRejectedList[ranFuncIdx].id;
2696 fillE2FailureCause(&ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.cause, CauseE2_PR_ricService,\
2697 CauseE2RICservice_ran_function_not_supported);
2703 /*******************************************************************
2705 * @brief build and send the ric service update Acknowledge
2709 * Function : BuildAndSendRicServiceUpdateAcknowledge
2711 * Functionality: build and send the ric service update Acknowledge
2712 * @return ROK - success
2713 * RFAILED - Acknowledge
2715 ******************************************************************/
2717 uint8_t BuildAndSendRicServiceUpdateAcknowledge(DuDb *duDb, int8_t transId, RicTmpRanFunList ricRanFuncList)
2719 E2AP_PDU_t *e2apMsg = NULL;
2720 asn_enc_rval_t encRetVal;
2721 uint8_t arrIdx=0, elementCnt=0, ret=RFAILED;;
2722 RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL;
2724 DU_LOG("\nINFO --> E2AP : Building Ric service update Acknowledge\n");
2727 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2728 if(e2apMsg == NULLP)
2730 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2733 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
2734 RIC_ALLOC(e2apMsg->choice.successfulOutcome , sizeof(struct SuccessfulOutcomeE2));
2735 if(e2apMsg->choice.successfulOutcome == NULLP)
2737 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2741 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
2742 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
2743 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge;
2744 ricServiceUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
2747 if(ricRanFuncList.numOfRanFunAccepted)
2749 if(ricRanFuncList.numOfRanFuneRejected)
2753 ricServiceUpdateAck->protocolIEs.list.count = elementCnt;
2754 ricServiceUpdateAck->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdateAcknowledge_IEs_t*);
2756 RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size);
2757 if(ricServiceUpdateAck->protocolIEs.list.array == NULLP)
2759 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
2763 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
2765 RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t));
2766 if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
2768 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
2772 if(arrIdx<elementCnt)
2774 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
2780 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2781 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2782 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_TransactionID;
2783 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
2785 if(ricRanFuncList.numOfRanFunAccepted)
2787 /* Accepted RAN function List */
2789 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
2790 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2791 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_RANfunctionsID_List;
2792 if(BuildRanFunctionAcceptedList(duDb, ricRanFuncList.numOfRanFunAccepted, ricRanFuncList.ranFunAcceptedList,\
2793 &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceUpdate)!=ROK)
2795 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
2800 if(ricRanFuncList.numOfRanFuneRejected)
2802 /* RAN Functions Rejected List */
2804 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsRejected;
2805 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2806 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_RANfunctionsIDcause_List;
2807 if(BuildRanFunctionRejectedList(ricRanFuncList.numOfRanFuneRejected, ricRanFuncList.ranFunRejectedList, \
2808 &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List)!=ROK)
2810 DU_LOG("\nERROR --> E2AP : Failed to build Ran function rejected list");
2816 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2817 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2819 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2821 /* Check encode results */
2822 if(encRetVal.encoded == ENCODE_FAIL)
2824 DU_LOG("\nERROR --> E2AP : Could not encode RIC service update Acknowledge structure (at %s)\n",\
2825 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2830 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Acknowledge\n");
2831 for(int i=0; i< encBufSize; i++)
2833 DU_LOG("%x",encBuf[i]);
2837 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
2839 DU_LOG("\nERROR --> E2AP : Sending RIC service update ack failed");
2845 FreeRicServiceUpdateAck(e2apMsg);
2849 /*******************************************************************
2851 * @brief process the RIC service update
2855 * Function : ProcRicserviceUpdate
2857 * Functionality: process the RIC service update
2859 * @return ROK - success
2862 ******************************************************************/
2864 void ProcRicServiceUpdate(uint32_t duId, RICserviceUpdate_t *ricServiceUpdate)
2866 RicTmpRanFunList ricRanFuncList;
2869 uint8_t duIdx = 0, elementCnt =0, arrIdx = 0;
2870 uint16_t ranFuncIdx = 0, failedRanFuncCount=0, recvdRanFuncCount=0;
2871 RanFunction *ranFuncDb = NULLP;
2872 RANfunction_ItemIEs_t *ranFuncItemIe =NULL;
2873 RANfunction_Item_t *ranFuncItem =NULL;
2874 RANfunctionID_Item_t *ranFuncIdItem=NULL;
2875 RANfunctions_List_t *ranFuncList=NULL;
2876 RANfunctionsID_List_t *deleteList=NULL;
2877 RANfunctionID_ItemIEs_t *delRanFuncItem=NULL;
2879 SEARCH_DU_DB(duIdx, duId, duDb);
2882 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
2885 memset(&ricRanFuncList, 0, sizeof(RicTmpRanFunList));
2887 if(!ricServiceUpdate)
2889 DU_LOG("\nERROR --> E2AP : ricServiceUpdate pointer is null");
2893 if(!ricServiceUpdate->protocolIEs.list.array)
2895 DU_LOG("\nERROR --> E2AP : ricServiceUpdate array pointer is null");
2898 elementCnt = ricServiceUpdate->protocolIEs.list.count;
2899 for(arrIdx=0; arrIdx<ricServiceUpdate->protocolIEs.list.count; arrIdx++)
2901 if(!ricServiceUpdate->protocolIEs.list.array[arrIdx])
2903 DU_LOG("\nERROR --> E2AP : ricServiceUpdate array idx %d pointer is null",arrIdx);
2907 switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id)
2909 case ProtocolIE_IDE2_id_TransactionID:
2911 transId = ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
2913 if(transId < 0 || transId > 255)
2915 DU_LOG("\nERROR --> E2AP : Received invalid transId %d",transId);
2921 case ProtocolIE_IDE2_id_RANfunctionsAdded:
2923 ranFuncList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
2925 if(ranFuncList->list.array)
2927 for(ranFuncIdx=0;ranFuncIdx<ranFuncList->list.count; ranFuncIdx++)
2929 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx];
2930 ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
2932 /* Adding the ran function in temporary list */
2933 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].id = ranFuncItem->ranFunctionID;
2934 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].revisionCounter = ranFuncItem->ranFunctionRevision;
2935 ricRanFuncList.numOfRanFunAccepted++;
2937 /* Adding the new ran function in DB*/
2938 duDb->ranFunction[ranFuncItem->ranFunctionID-1].id = ranFuncItem->ranFunctionID;
2939 duDb->ranFunction[ranFuncItem->ranFunctionID-1].revisionCounter = ranFuncItem->ranFunctionRevision;
2940 duDb->numOfRanFunction++;
2942 /* Calculating total number of ran fuctions which are received for addition */
2943 recvdRanFuncCount++;
2949 case ProtocolIE_IDE2_id_RANfunctionsModified:
2952 ranFuncList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
2953 if(ranFuncList->list.array)
2955 for(ranFuncIdx = 0; ranFuncIdx< ranFuncList->list.count; ranFuncIdx++)
2957 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx];
2958 ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
2959 if(fetchRanFuncFromRanFuncId(duDb, ranFuncItem->ranFunctionID) == NULLP)
2961 /* Calculating total number of ran fuctions which are not present */
2962 failedRanFuncCount++;
2964 /* Adding the ran function in temporary list */
2965 ricRanFuncList.ranFunRejectedList[ricRanFuncList.numOfRanFuneRejected].id = ranFuncItem->ranFunctionID;
2966 ricRanFuncList.numOfRanFuneRejected++;
2971 /* Adding the ran function in temporary list */
2972 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].id = ranFuncItem->ranFunctionID;
2973 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].revisionCounter = ranFuncItem->ranFunctionRevision;
2974 ricRanFuncList.numOfRanFunAccepted++;
2976 /* Updating the new ran function in DB*/
2977 duDb->ranFunction[ranFuncItem->ranFunctionID-1].revisionCounter = ranFuncItem->ranFunctionRevision;
2979 /* Calculating total number of ran fuctions which are received for modification */
2980 recvdRanFuncCount++;
2985 case ProtocolIE_IDE2_id_RANfunctionsDeleted:
2988 deleteList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
2989 if(deleteList->list.array)
2991 for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++)
2993 delRanFuncItem = (RANfunctionID_ItemIEs_t*) deleteList->list.array[ranFuncIdx];
2994 ranFuncIdItem = &delRanFuncItem->value.choice.RANfunctionID_Item;
2995 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncIdItem->ranFunctionID);
2998 memset(ranFuncDb, 0, sizeof(RanFunction));
2999 duDb->numOfRanFunction--;
3002 /* Calculating total number of ran fuctions which are received for deletion */
3003 recvdRanFuncCount++;
3011 DU_LOG("\nERROR --> E2AP : IE [%ld] is not supported",ricServiceUpdate->protocolIEs.list.array[arrIdx]->id);
3017 /* Sending RIC Service Update Failed if all RAN Functions received fail or if any IE processing fails
3018 * Else sending RIC Service Update Acknowledge */
3019 if((elementCnt > arrIdx) ||((recvdRanFuncCount > 0) && (recvdRanFuncCount == failedRanFuncCount)))
3021 if(BuildAndSendRicServiceUpdateFailure(duDb->duId, transId, CauseE2_PR_misc, CauseE2Misc_unspecified) != ROK)
3023 DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update Failure");
3029 if(BuildAndSendRicServiceUpdateAcknowledge(duDb, transId, ricRanFuncList) != ROK)
3031 DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update acknowledge");
3037 /*******************************************************************
3039 * @brief Processing RIC subscription failure from DU
3043 * Function : ProcRicSubscriptionFailure
3045 * Functionality: Processing RIC subscription failure from DU
3047 * @param ID of DU from which message was sent
3048 * RIC Subscription failure message
3049 * @return ROK - success
3052 ******************************************************************/
3053 uint8_t ProcRicSubscriptionFailure(uint32_t duId, RICsubscriptionFailure_t *ricSubscriptionFailure)
3055 uint8_t ieIdx = 0, duIdx = 0, subsIdx = 0;
3056 uint8_t ranFuncId = 0;
3058 RanFunction *ranFuncDb = NULLP;
3059 RicSubscription *ricSubs = NULLP;
3060 RicRequestId ricReqId;
3061 RICsubscriptionFailure_IEs_t *ricSubsFailIe = NULLP;
3063 DU_LOG("\nINFO --> E2AP : Received RIC subscription failure");
3065 SEARCH_DU_DB(duIdx, duId, duDb);
3068 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
3072 memset(&ricReqId, 0, sizeof(RicRequestId));
3073 if(ricSubscriptionFailure)
3075 if(ricSubscriptionFailure->protocolIEs.list.array)
3077 for(ieIdx=0; ieIdx<ricSubscriptionFailure->protocolIEs.list.count; ieIdx++)
3079 if(ricSubscriptionFailure->protocolIEs.list.array[ieIdx])
3081 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[ieIdx];
3082 switch(ricSubscriptionFailure->protocolIEs.list.array[ieIdx]->id)
3084 case ProtocolIE_IDE2_id_RICrequestID:
3086 ricReqId.requestorId = ricSubsFailIe->value.choice.RICrequestID.ricRequestorID;
3087 ricReqId.instanceId = ricSubsFailIe->value.choice.RICrequestID.ricInstanceID;
3090 case ProtocolIE_IDE2_id_RANfunctionID:
3092 ranFuncId = ricSubsFailIe->value.choice.RANfunctionID;
3093 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
3096 DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionFailure : RAN Function Id [%d] not found", ranFuncId);
3101 /* Remove subscription entry from RAN Function */
3102 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb);
3105 memset(&ranFuncDb->subscriptionList[subsIdx], 0, sizeof(RicSubscription));
3110 case ProtocolIE_IDE2_id_CauseE2:
3112 /* No handling required as of now since this is a stub */
3122 /*******************************************************************
3124 * @brief Free RIC Subscription Modification Refuse
3128 * Function : FreeRicSubsModRefuse
3130 * Functionality: Free RIC Subscription Modification Refuse
3132 * @param E2AP Message PDU to be freed
3135 ******************************************************************/
3136 void FreeRicSubsModRefuse(E2AP_PDU_t *e2apMsg)
3139 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
3143 if(e2apMsg->choice.unsuccessfulOutcome)
3145 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
3146 if(ricSubsModRefuse->protocolIEs.list.array)
3148 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
3150 RIC_FREE(ricSubsModRefuse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRefuse_IEs_t));
3152 RIC_FREE(ricSubsModRefuse->protocolIEs.list.array, ricSubsModRefuse->protocolIEs.list.size);
3154 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome , sizeof(UnsuccessfulOutcomeE2_t));
3156 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3160 /*******************************************************************
3162 * @brief Build And Send RIC Subscription Modification Refuse
3166 * Function : BuildAndSendRicSubsModRefuse
3168 * Functionality: Build And Send RIC Subscription Modification Refuse
3171 * RIC Request ID of subscription
3175 * @return ROK - success
3178 ******************************************************************/
3179 uint8_t BuildAndSendRicSubsModRefuse(uint32_t duId, RicRequestId ricReqId, uint16_t ranFuncId, CauseE2_PR causeType, \
3182 uint8_t ieIdx = 0, elementCnt = 0;
3183 uint8_t ret = RFAILED;
3184 E2AP_PDU_t *e2apMsg = NULL;
3185 asn_enc_rval_t encRetVal;
3186 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
3187 RICsubscriptionModificationRefuse_IEs_t *ricSubsModRefuseIe = NULLP;
3189 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Refuse\n");
3192 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3193 if(e2apMsg == NULLP)
3195 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3198 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
3199 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(UnsuccessfulOutcomeE2_t));
3200 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
3202 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3206 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
3207 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
3208 e2apMsg->choice.unsuccessfulOutcome->value.present = \
3209 UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationRefuse;
3210 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
3213 ricSubsModRefuse->protocolIEs.list.count = elementCnt;
3214 ricSubsModRefuse->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRefuse_IEs_t *);
3215 RIC_ALLOC(ricSubsModRefuse->protocolIEs.list.array, ricSubsModRefuse->protocolIEs.list.size);
3216 if(!ricSubsModRefuse->protocolIEs.list.array)
3218 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3222 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
3224 RIC_ALLOC(ricSubsModRefuse->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRefuse_IEs_t));
3225 if(!ricSubsModRefuse->protocolIEs.list.array[ieIdx])
3227 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3232 /* RIC Request ID */
3234 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
3235 ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_RICrequestID;
3236 ricSubsModRefuseIe->criticality = CriticalityE2_reject;
3237 ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_RICrequestID;
3238 ricSubsModRefuseIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
3239 ricSubsModRefuseIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
3241 /* RAN Function ID */
3243 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
3244 ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_RANfunctionID;
3245 ricSubsModRefuseIe->criticality = CriticalityE2_reject;
3246 ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_RANfunctionID;
3247 ricSubsModRefuseIe->value.choice.RANfunctionID = ranFuncId;
3251 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
3252 ricSubsModRefuseIe->id = ProtocolIE_IDE2_id_CauseE2;
3253 ricSubsModRefuseIe->criticality = CriticalityE2_reject;
3254 ricSubsModRefuseIe->value.present = RICsubscriptionModificationRefuse_IEs__value_PR_CauseE2;
3255 fillE2FailureCause(&ricSubsModRefuseIe->value.choice.CauseE2, causeType, cause);
3257 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3258 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3260 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3262 /* Check encode results */
3263 if(encRetVal.encoded == ENCODE_FAIL)
3265 DU_LOG("\nERROR --> E2AP : Could not encode RIC subscription modification refuse (at %s)\n",\
3266 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3271 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription modification refuse\n");
3272 for(int i=0; i< encBufSize; i++)
3274 DU_LOG("%x",encBuf[i]);
3278 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
3280 DU_LOG("\nERROR --> E2AP : Failed to send RIC Subscription Modification Refused");
3287 FreeRicSubsModRefuse(e2apMsg);
3291 /*******************************************************************
3293 * @brief Free memory for RIC Subscription Modification Confirm
3297 * Function : FreeRicSubsModConfirm
3299 * Functionality: Free memory for RIC subscription modification
3302 * @param E2AP Message PDU to be freed
3305 ******************************************************************/
3306 void FreeRicSubsModConfirm(E2AP_PDU_t *e2apMsg)
3308 uint8_t ieIdx = 0, arrIdx=0;
3309 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
3310 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
3311 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
3312 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
3313 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
3314 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
3318 if(e2apMsg->choice.successfulOutcome)
3320 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
3321 if(ricSubsModCfm->protocolIEs.list.array)
3323 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
3325 if(ricSubsModCfm->protocolIEs.list.array[ieIdx])
3327 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
3328 switch(ricSubsModCfmIe->id)
3330 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
3332 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
3333 if(modCfmList->list.array)
3335 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
3337 RIC_FREE(modCfmList->list.array[arrIdx], \
3338 sizeof(RICaction_ConfirmedForModification_ItemIEs_t));
3340 RIC_FREE(modCfmList->list.array, modCfmList->list.size);
3345 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
3347 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
3348 if(modRefusedList->list.array)
3350 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
3352 RIC_FREE(modRefusedList->list.array[arrIdx], \
3353 sizeof(RICaction_RefusedToBeModified_ItemIEs_t));
3355 RIC_FREE(modRefusedList->list.array, modRefusedList->list.size);
3360 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
3362 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
3363 if(rmvCfmList->list.array)
3365 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
3367 RIC_FREE(rmvCfmList->list.array[arrIdx], \
3368 sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t));
3370 RIC_FREE(rmvCfmList->list.array, rmvCfmList->list.size);
3375 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
3377 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
3378 if(rmvFailList->list.array)
3380 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
3382 RIC_ALLOC(rmvFailList->list.array[arrIdx], \
3383 sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t));
3385 RIC_FREE(rmvFailList->list.array, rmvFailList->list.size);
3394 RIC_FREE(ricSubsModCfmIe, sizeof(RICsubscriptionModificationConfirm_IEs_t));
3397 RIC_FREE(ricSubsModCfm->protocolIEs.list.array, ricSubsModCfm->protocolIEs.list.size);
3399 RIC_FREE(e2apMsg->choice.successfulOutcome , sizeof(SuccessfulOutcomeE2_t));
3401 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3405 /*******************************************************************
3407 * @brief Fill the list of actions confirmed for modification
3411 * Function : fillActionModConfirmedList
3413 * Functionality: Fill the list of actions confirmed for modification
3415 * @param List to be filled
3417 * Source list of actions
3418 * @return ROK - success
3421 ******************************************************************/
3422 uint8_t fillActionModConfirmedList(RICactions_ConfirmedForModification_List_t *modCfmList, uint8_t numActions, \
3423 uint8_t *actionModifiedList)
3426 RICaction_ConfirmedForModification_ItemIEs_t *modCfmListItem = NULLP;
3428 modCfmList->list.count = numActions;
3429 modCfmList->list.size = numActions * sizeof(RICaction_ConfirmedForModification_ItemIEs_t *);
3430 RIC_ALLOC(modCfmList->list.array, modCfmList->list.size);
3431 if(!modCfmList->list.array)
3433 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3437 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
3439 RIC_ALLOC(modCfmList->list.array[arrIdx], sizeof(RICaction_ConfirmedForModification_ItemIEs_t));
3440 if(!modCfmList->list.array[arrIdx])
3442 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3446 modCfmListItem = (RICaction_ConfirmedForModification_ItemIEs_t *)modCfmList->list.array[arrIdx];
3447 modCfmListItem->id = ProtocolIE_IDE2_id_RICaction_ConfirmedForModification_Item;
3448 modCfmListItem->criticality = CriticalityE2_ignore;
3449 modCfmListItem->value.present = \
3450 RICaction_ConfirmedForModification_ItemIEs__value_PR_RICaction_ConfirmedForModification_Item;
3451 modCfmListItem->value.choice.RICaction_ConfirmedForModification_Item.ricActionID = actionModifiedList[arrIdx];
3457 /*******************************************************************
3459 * @brief Fill the list of actions refused to be modified
3463 * Function : fillActionModRefusedList
3465 * Functionality: Fill the list of actions refused to be modified
3467 * @param List to be filled
3469 * Source list of actions refused tobe modified
3470 * @return ROK - success
3473 ******************************************************************/
3474 uint8_t fillActionModRefusedList(RICactions_RefusedToBeModified_List_t *modRefusedList, uint8_t numActions, \
3475 ActionFailed *actionModFailedList)
3478 RICaction_RefusedToBeModified_ItemIEs_t *modRefusedListItem = NULLP;
3480 modRefusedList->list.count = numActions;
3481 modRefusedList->list.size = numActions * sizeof(RICaction_RefusedToBeModified_ItemIEs_t *);
3482 RIC_ALLOC(modRefusedList->list.array, modRefusedList->list.size);
3483 if(!modRefusedList->list.array)
3485 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3489 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
3491 RIC_ALLOC(modRefusedList->list.array[arrIdx], sizeof(RICaction_RefusedToBeModified_ItemIEs_t));
3492 if(!modRefusedList->list.array[arrIdx])
3494 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3498 modRefusedListItem = (RICaction_RefusedToBeModified_ItemIEs_t *)modRefusedList->list.array[arrIdx];
3499 modRefusedListItem->id = ProtocolIE_IDE2_id_RICaction_RefusedToBeModified_Item;
3500 modRefusedListItem->criticality = CriticalityE2_ignore;
3501 modRefusedListItem->value.present = \
3502 RICaction_RefusedToBeModified_ItemIEs__value_PR_RICaction_RefusedToBeModified_Item;
3503 modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.ricActionID = \
3504 actionModFailedList[arrIdx].actionId;
3505 fillE2FailureCause(&modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.cause, \
3506 actionModFailedList[arrIdx].failureType, actionModFailedList[arrIdx].cause);
3512 /*******************************************************************
3514 * @brief Fill the list of action confirmed for removal
3518 * Function : fillActionRemovalConfirmedList
3520 * Functionality: Fill the list of action confirmed for removal
3522 * @param List to be filled
3524 * Source list of actions removed
3525 * @return ROK - success
3528 ******************************************************************/
3529 uint8_t fillActionRemovalConfirmedList(RICactions_ConfirmedForRemoval_List_t *rmvCfmList, uint8_t numActions, \
3530 uint8_t *actionRemovedList)
3533 RICaction_ConfirmedForRemoval_ItemIEs_t *rmvCfmListItem = NULLP;
3535 rmvCfmList->list.count = numActions;
3536 rmvCfmList->list.size = numActions * sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t *);
3537 RIC_ALLOC(rmvCfmList->list.array, rmvCfmList->list.size);
3538 if(!rmvCfmList->list.array)
3540 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3544 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
3546 RIC_ALLOC(rmvCfmList->list.array[arrIdx], sizeof(RICaction_ConfirmedForRemoval_ItemIEs_t));
3547 if(!rmvCfmList->list.array[arrIdx])
3549 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3553 rmvCfmListItem = (RICaction_ConfirmedForRemoval_ItemIEs_t *)rmvCfmList->list.array[arrIdx];
3554 rmvCfmListItem->id = ProtocolIE_IDE2_id_RICaction_ConfirmedForRemoval_Item;
3555 rmvCfmListItem->criticality = CriticalityE2_ignore;
3556 rmvCfmListItem->value.present = \
3557 RICaction_ConfirmedForRemoval_ItemIEs__value_PR_RICaction_ConfirmedForRemoval_Item;
3558 rmvCfmListItem->value.choice.RICaction_ConfirmedForRemoval_Item.ricActionID = actionRemovedList[arrIdx];
3564 /*******************************************************************
3566 * @brief Fill the list of actions refused to be removed
3570 * Function : fillActionRemovalRefusedList
3572 * Functionality: Fill the list of actions refused to be removed
3574 * @param List to be filled
3576 * Source list of actions refused to be removed
3577 * @return ROK - success
3580 ******************************************************************/
3581 uint8_t fillActionRemovalRefusedList(RICactions_RefusedToBeRemoved_List_t *rmvFailList, \
3582 uint8_t numActions, ActionFailed *actionRmvlFailList)
3585 RICaction_RefusedToBeRemoved_ItemIEs_t *rmvFailListItem = NULLP;
3587 rmvFailList->list.count = numActions;
3588 rmvFailList->list.size = numActions * sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t *);
3589 RIC_ALLOC(rmvFailList->list.array, rmvFailList->list.size);
3590 if(!rmvFailList->list.array)
3592 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3596 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
3598 RIC_ALLOC(rmvFailList->list.array[arrIdx], sizeof(RICaction_RefusedToBeRemoved_ItemIEs_t));
3599 if(!rmvFailList->list.array[arrIdx])
3601 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3605 rmvFailListItem = (RICaction_RefusedToBeRemoved_ItemIEs_t *)rmvFailList->list.array[arrIdx];
3606 rmvFailListItem->id = ProtocolIE_IDE2_id_RICaction_RefusedToBeRemoved_Item;
3607 rmvFailListItem->criticality = CriticalityE2_ignore;
3608 rmvFailListItem->value.present = \
3609 RICaction_RefusedToBeRemoved_ItemIEs__value_PR_RICaction_RefusedToBeRemoved_Item;
3610 rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.ricActionID = actionRmvlFailList[arrIdx].actionId;
3611 fillE2FailureCause(&rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.cause, \
3612 actionRmvlFailList[arrIdx].failureType, actionRmvlFailList[arrIdx].cause);
3619 /*******************************************************************
3621 * @brief Build And Send RIC Subscription Modification Confirm
3625 * Function : BuildAndSendRicSubsModConfirm
3627 * Functionality: Build And Send RIC Subscription Modification Confirm
3630 * RIC Request ID of subscription
3632 * Temporary source action list
3633 * @return ROK - success
3636 ******************************************************************/
3637 uint8_t BuildAndSendRicSubsModConfirm(uint32_t duId, RicRequestId ricReqId, uint16_t ranFuncId, RicTmpActionList tmpActionList)
3639 uint8_t ieIdx = 0, elementCnt = 0;
3640 uint8_t ret = RFAILED;
3641 E2AP_PDU_t *e2apMsg = NULLP;
3642 asn_enc_rval_t encRetVal;
3643 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
3644 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
3646 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Confirm\n");
3649 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3650 if(e2apMsg == NULLP)
3652 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3656 /* Successful Outcome */
3657 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
3658 RIC_ALLOC(e2apMsg->choice.successfulOutcome , sizeof(SuccessfulOutcomeE2_t));
3659 if(e2apMsg->choice.successfulOutcome == NULLP)
3661 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3665 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
3666 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
3667 e2apMsg->choice.successfulOutcome->value.present = \
3668 SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationConfirm;
3669 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
3672 if(tmpActionList.numActionModified)
3674 if(tmpActionList.numActionModFailed)
3676 if(tmpActionList.numActionRemoved)
3678 if(tmpActionList.numActionRemovalFailed)
3681 ricSubsModCfm->protocolIEs.list.count = elementCnt;
3682 ricSubsModCfm->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationConfirm_IEs_t *);
3683 RIC_ALLOC(ricSubsModCfm->protocolIEs.list.array, ricSubsModCfm->protocolIEs.list.size);
3684 if(!ricSubsModCfm->protocolIEs.list.array)
3686 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3690 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
3692 RIC_ALLOC(ricSubsModCfm->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationConfirm_IEs_t));
3693 if(!ricSubsModCfm->protocolIEs.list.array[ieIdx])
3695 DU_LOG("\nERROR --> E2AP : Memory allocation failed for %s at line %d", __func__, __LINE__);
3700 /* RIC Request ID */
3702 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
3703 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICrequestID;
3704 ricSubsModCfmIe->criticality = CriticalityE2_reject;
3705 ricSubsModCfmIe->value.present = RICsubscriptionModificationConfirm_IEs__value_PR_RICrequestID;
3706 ricSubsModCfmIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
3707 ricSubsModCfmIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
3709 /* RAN Function ID */
3711 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
3712 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RANfunctionID;
3713 ricSubsModCfmIe->criticality = CriticalityE2_reject;
3714 ricSubsModCfmIe->value.present = RICsubscriptionModificationConfirm_IEs__value_PR_RANfunctionID;
3715 ricSubsModCfmIe->value.choice.RANfunctionID = ranFuncId;
3717 /* RIC Actions List confirmed for modification */
3718 if(tmpActionList.numActionModified)
3721 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
3722 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List;
3723 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
3724 ricSubsModCfmIe->value.present = \
3725 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_ConfirmedForModification_List;
3726 if(fillActionModConfirmedList(&ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List, \
3727 tmpActionList.numActionModified, tmpActionList.actionModifiedList) != ROK)
3729 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Confirmed for Modification List", __func__);
3734 /* RIC Actions List refured to be modified */
3735 if(tmpActionList.numActionModFailed)
3738 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
3739 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List;
3740 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
3741 ricSubsModCfmIe->value.present = \
3742 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_RefusedToBeModified_List;
3743 if(fillActionModRefusedList(&ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List, \
3744 tmpActionList.numActionModFailed, tmpActionList.actionModFailedList) != ROK)
3746 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Refused to be Modified List", __func__);
3751 /* RIC Actions List confirmed for removal */
3752 if(tmpActionList.numActionRemoved)
3755 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
3756 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List;
3757 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
3758 ricSubsModCfmIe->value.present = \
3759 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_ConfirmedForRemoval_List;
3760 if(fillActionRemovalConfirmedList(&ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List, \
3761 tmpActionList.numActionRemoved, tmpActionList.actionRemovedList) != ROK)
3763 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Confirmed for Removal List", __func__);
3768 /* RIC Actions List Refused to be removed */
3769 if(tmpActionList.numActionRemovalFailed)
3772 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
3773 ricSubsModCfmIe->id = ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List;
3774 ricSubsModCfmIe->criticality = CriticalityE2_ignore;
3775 ricSubsModCfmIe->value.present = \
3776 RICsubscriptionModificationConfirm_IEs__value_PR_RICactions_RefusedToBeRemoved_List;
3777 if(fillActionRemovalRefusedList(&ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List, \
3778 tmpActionList.numActionRemovalFailed, tmpActionList.actionRemovalFailedList) != ROK)
3780 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Actions Failed to be Removed List", __func__);
3785 /* Print and encode E2AP Message PDU */
3786 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3787 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3789 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3791 /* Check encode results */
3792 if(encRetVal.encoded == ENCODE_FAIL)
3794 DU_LOG("\nERROR --> E2AP : Could not encode RIC subscription modification confirm (at %s)\n",\
3795 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3800 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription modification confirm\n");
3801 for(int i=0; i< encBufSize; i++)
3803 DU_LOG("%x",encBuf[i]);
3807 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
3809 DU_LOG("\nERROR --> E2AP : Failed to send RIC Subscription Modification Confirm");
3817 FreeRicSubsModConfirm(e2apMsg);
3821 /*******************************************************************
3823 * @brief Processing of RIC Subscription Modification Required
3827 * Function : ProcRicSubsModReqd
3829 * Functionality: Processing of RIC Subscription Modification Required
3830 * As of now, we do not identify any scenario where this message
3831 * shall be sent by DU. Hence, bare minimum handling has been
3835 * RIC Subscription Modification Required IEs
3836 * @return ROK-success
3839 ******************************************************************/
3840 uint8_t ProcRicSubsModReqd(uint32_t duId, RICsubscriptionModificationRequired_t *ricSubsModReqd)
3842 uint8_t ieIdx = 0, actionIdx = 0, duIdx = 0;
3846 RicRequestId ricReqId;
3847 RanFunction *ranFuncDb = NULLP;
3848 RicSubscription *ricSubs = NULLP;
3849 ActionInfo *action = NULLP;
3850 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
3851 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
3852 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
3853 RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULLP;
3854 RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULLP;
3855 RicTmpActionList tmpActionList;
3857 memset(&ricReqId, 0, sizeof(RicRequestId));
3858 memset(&tmpActionList, 0, sizeof(RicTmpActionList));
3860 SEARCH_DU_DB(duIdx, duId, duDb);
3863 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
3867 for(ieIdx = 0; ieIdx < ricSubsModReqd->protocolIEs.list.count; ieIdx++)
3869 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
3870 switch(ricSubsModReqdIe->id)
3872 case ProtocolIE_IDE2_id_RICrequestID:
3874 ricReqId.requestorId = ricSubsModReqdIe->value.choice.RICrequestID.ricRequestorID;
3875 ricReqId.instanceId = ricSubsModReqdIe->value.choice.RICrequestID.ricInstanceID;
3878 case ProtocolIE_IDE2_id_RANfunctionID:
3880 ranFuncId = ricSubsModReqdIe->value.choice.RANfunctionID;
3881 ranFuncDb = fetchRanFuncFromRanFuncId(duDb, ranFuncId);
3884 /* If RIC Subscription not found, send RIC Subscription modification refuse to DU */
3885 DU_LOG("\nERROR --> E2AP : ProcRicSubsModReqd: RIC Subscription not found");
3886 BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, CauseE2_PR_ricRequest, \
3887 CauseE2RICrequest_ran_function_id_invalid);
3891 ricSubs = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb);
3894 /* If RAN Function not found, send RIC Subscription modification refuse to DU */
3895 DU_LOG("\nERROR --> E2AP : ProcRicSubsModReqd: RAN Function ID [%d] not found",ranFuncId);
3896 BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, \
3897 CauseE2_PR_ricRequest, CauseE2RICrequest_request_id_unknown);
3902 case ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List:
3904 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
3905 for(actionIdx = 0; actionIdx < actionToBeModList->list.count; actionIdx++)
3907 actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[actionIdx];
3908 actionId = actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID;
3909 action = fetchActionInfoFromActionId(actionId, ricSubs);
3912 /* No modification required as of now, hence directly adding to the list */
3913 tmpActionList.actionModifiedList[tmpActionList.numActionModified++] = actionId;
3917 tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].actionId = actionId;
3918 tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].failureType = \
3919 CauseE2_PR_ricRequest;
3920 tmpActionList.actionModFailedList[tmpActionList.numActionModFailed].cause = \
3921 CauseE2RICrequest_action_not_supported;
3922 tmpActionList.numActionModFailed++;
3927 case ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List:
3929 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
3930 for(actionIdx = 0; actionIdx < actionToBeRmvList->list.count; actionIdx++)
3932 actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[actionIdx];
3933 actionId = actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID;
3934 action = fetchActionInfoFromActionId(actionId, ricSubs);
3937 tmpActionList.actionRemovedList[tmpActionList.numActionRemoved++] = actionId;
3938 memset(action, 0, sizeof(ActionInfo));
3939 action->actionId = -1;
3940 ricSubs->numOfActions--;
3950 /* If none of the action modification/removal is supported,
3951 * send RIC Subscription Modification Refuse
3953 * send RIC Subscription Modification Confirm
3955 if(tmpActionList.numActionModified || tmpActionList.numActionRemoved)
3957 BuildAndSendRicSubsModConfirm(duId, ricReqId, ranFuncId, tmpActionList);
3961 BuildAndSendRicSubsModRefuse(duId, ricReqId, ranFuncId, CauseE2_PR_ricRequest, \
3962 CauseE2RICrequest_action_not_supported);
3968 /*******************************************************************
3970 * @brief Free the ErrorIndication Message
3974 * Function : FreeRicIndication
3976 * Functionality: Free the ErrorIndication Message
3981 ******************************************************************/
3982 void FreeErrorIndication(E2AP_PDU_t *e2apMsg)
3985 ErrorIndicationE2_t *errorIndicationMsg= NULLP;
3987 if(e2apMsg != NULLP)
3989 if(e2apMsg->choice.initiatingMessage != NULLP)
3991 errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
3992 if(errorIndicationMsg!= NULLP)
3994 if(errorIndicationMsg->protocolIEs.list.array != NULLP)
3996 for(arrIdx=0; arrIdx<errorIndicationMsg->protocolIEs.list.count; arrIdx++)
3998 RIC_FREE(errorIndicationMsg->protocolIEs.list.array[arrIdx],sizeof(ErrorIndicationE2_t));
4000 RIC_FREE(errorIndicationMsg->protocolIEs.list.array,errorIndicationMsg->protocolIEs.list.size);
4003 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4005 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4010 /*******************************************************************
4012 * @brief Builds and Send the ErrorIndication Message
4016 * Function : BuildAndSendErrorIndication
4018 * Functionality:Fills the ErrorIndication Message
4026 * @return ROK - success
4029 ******************************************************************/
4031 uint8_t BuildAndSendErrorIndication(uint32_t duId, int8_t transId, RicRequestId requestId, uint16_t ranFuncId, uint8_t reason)
4033 uint8_t elementCnt =0, arrIdx=0, ret = RFAILED;
4034 E2AP_PDU_t *e2apMsg = NULLP;
4035 ErrorIndicationE2_t *errorIndicationMsg=NULLP;
4036 asn_enc_rval_t encRetVal; /* Encoder return value */
4040 DU_LOG("\nINFO --> E2AP : Building Error Indication Message\n");
4042 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4043 if(e2apMsg == NULLP)
4045 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
4049 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4050 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4051 if(e2apMsg->choice.initiatingMessage == NULLP)
4053 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
4056 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_ErrorIndicationE2;
4057 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4058 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ErrorIndicationE2;
4060 errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
4062 /* Element count is 2 for TransactionID/RICrequestID and Cause.
4063 * If the RAN function id is present, the count will be increased.*/
4068 errorIndicationMsg->protocolIEs.list.count = elementCnt;
4069 errorIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(ErrorIndicationE2_IEs_t*);
4071 /* Initialize the E2Setup members */
4072 RIC_ALLOC(errorIndicationMsg->protocolIEs.list.array, errorIndicationMsg->protocolIEs.list.size);
4073 if(errorIndicationMsg->protocolIEs.list.array == NULLP)
4075 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements in %s at line %d",__func__, __LINE__);
4078 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
4080 RIC_ALLOC(errorIndicationMsg->protocolIEs.list.array[arrIdx], sizeof(ErrorIndicationE2_IEs_t));
4081 if(errorIndicationMsg->protocolIEs.list.array[arrIdx] == NULLP)
4083 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array Idx %d in %s at line %d",arrIdx,__func__, __LINE__);
4087 if(arrIdx < elementCnt)
4092 if(transId >=0 && transId<=255)
4095 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
4096 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4097 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_TransactionID;
4098 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
4103 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RICrequestID;
4104 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4105 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RICrequestID;
4106 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricRequestorID = requestId.requestorId;
4107 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
4112 /* RAN Function ID */
4114 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionID;
4115 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4116 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RANfunctionID;
4117 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionID = ranFuncId;
4122 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
4123 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
4124 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
4125 fillE2FailureCause(&errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, CauseE2_PR_misc, reason);
4128 /* Prints the Msg formed */
4129 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4130 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4132 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
4134 if(encRetVal.encoded == ENCODE_FAIL)
4136 DU_LOG("\nERROR --> E2AP : Could not encode Error Indication Message (at %s)\n",\
4137 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4142 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for Error Indication Message \n");
4143 #ifdef DEBUG_ASN_PRINT
4144 for(int i=0; i< encBufSize; i++)
4146 printf("%x",encBuf[i]);
4151 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
4153 DU_LOG("\nINFO --> E2AP : Sending Error Indication Message");
4159 FreeErrorIndication(e2apMsg);
4163 /*******************************************************************
4165 * @brief Deallocate the memory allocated for ResetRequest msg
4169 * Function : FreeResetRequest
4172 * - freeing the memory allocated for ResetRequest
4174 * @params[in] E2AP_PDU_t *e2apMsg
4175 * @return ROK - success
4178 * ****************************************************************/
4179 void FreeResetRequest(E2AP_PDU_t *e2apMsg)
4182 ResetRequestE2_t *resetReq = NULLP;
4184 if(e2apMsg != NULLP)
4186 if(e2apMsg->choice.initiatingMessage != NULLP)
4188 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
4189 if(resetReq->protocolIEs.list.array)
4191 for(ieIdx = 0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
4193 RIC_FREE(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
4195 RIC_FREE(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
4197 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4199 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4203 /*******************************************************************
4205 * @brief Build and send the reset request msg
4209 * Function : BuildAndSendResetRequest
4212 * - Buld and send the reset request msg to E2 node
4218 * @return ROK - success
4221 * ****************************************************************/
4222 uint8_t BuildAndSendResetRequest(DuDb *duDb, CauseE2_PR causePresent, uint8_t reason)
4224 uint8_t ieIdx = 0, elementCnt = 0, transId = 0;
4225 uint8_t ret = RFAILED;
4226 E2AP_PDU_t *e2apMsg = NULLP;
4227 ResetRequestE2_t *resetReq = NULLP;
4228 asn_enc_rval_t encRetVal; /* Encoder return value */
4230 DU_LOG("\nINFO --> E2AP : Building Reset Request\n");
4234 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4235 if(e2apMsg == NULLP)
4237 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation for E2AP-PDU failed");
4241 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4242 RIC_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4243 if(e2apMsg->choice.initiatingMessage == NULLP)
4245 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation for initiatingMessage");
4249 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset;
4250 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4251 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2;
4252 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
4255 resetReq->protocolIEs.list.count = elementCnt;
4256 resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *);
4258 RIC_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
4259 if(!resetReq->protocolIEs.list.array)
4261 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation failed for \
4262 Reset Request IE array");
4266 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
4268 RIC_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
4269 if(!resetReq->protocolIEs.list.array[ieIdx])
4271 DU_LOG("\nERROR --> E2AP : BuildAndSendResetRequest(): Memory allocation failed for \
4272 Reset Request IE array element");
4277 /* In case of failure */
4278 if(ieIdx < elementCnt)
4282 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
4283 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
4284 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID;
4285 transId = assignTransactionId(duDb);
4286 resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
4289 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
4290 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
4291 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2;
4292 fillE2FailureCause(&resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, causePresent, reason);
4294 /* Prints the Msg formed */
4295 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4297 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4299 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
4301 if(encRetVal.encoded == ENCODE_FAIL)
4303 DU_LOG("\nERROR --> E2AP : Could not encode reset request structure (at %s)\n",\
4304 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4309 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for reset request\n");
4310 #ifdef DEBUG_ASN_PRINT
4311 for(int i=0; i< encBufSize; i++)
4313 printf("%x",encBuf[i]);
4317 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
4319 DU_LOG("\nERROR --> E2AP : Sending reset request failed");
4328 /* Free all memory */
4329 FreeResetRequest(e2apMsg);
4333 /*******************************************************************
4335 * @brief Handles received E2AP message and sends back response
4339 * Function : E2APMsgHdlr
4342 * - Decodes received E2AP control message
4343 * - Prepares response message, encodes and sends to SCTP
4346 * @return ROK - success
4349 * ****************************************************************/
4350 void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf)
4356 E2AP_PDU_t *e2apMsg;
4357 asn_dec_rval_t rval; /* Decoder return value */
4358 E2AP_PDU_t e2apasnmsg ;
4360 DU_LOG("\nINFO --> E2AP : Received E2AP message buffer");
4361 ODU_PRINT_MSG(mBuf, 0,0);
4363 /* Copy mBuf into char array to decode it */
4364 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
4365 RIC_ALLOC(recvBuf, (Size)recvBufLen);
4367 if(recvBuf == NULLP)
4369 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
4372 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
4374 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
4378 DU_LOG("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
4379 for(i=0; i< recvBufLen; i++)
4381 DU_LOG("%x",recvBuf[i]);
4384 /* Decoding flat buffer into E2AP messsage */
4385 e2apMsg = &e2apasnmsg;
4386 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
4388 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
4389 RIC_FREE(recvBuf, (Size)recvBufLen);
4391 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
4393 DU_LOG("\nERROR --> E2AP : ASN decode failed");
4397 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4399 switch(e2apMsg->present)
4401 case E2AP_PDU_PR_initiatingMessage:
4403 switch(e2apMsg->choice.initiatingMessage->value.present)
4405 case InitiatingMessageE2__value_PR_E2setupRequest:
4407 DU_LOG("\nINFO --> E2AP : E2 setup request received");
4408 ProcE2SetupReq(duId, &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest);
4411 case InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate:
4413 DU_LOG("\nINFO --> E2AP : E2 node config update received");
4414 ProcE2NodeConfigUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate);
4417 case InitiatingMessageE2__value_PR_ResetRequestE2:
4419 DU_LOG("\nINFO --> E2AP : E2 Reset Request received");
4420 ProcE2ResetReq(*duId, &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2);
4423 case InitiatingMessageE2__value_PR_RICindication:
4425 DU_LOG("\nINFO --> E2AP : RIC Indication received");
4428 case InitiatingMessageE2__value_PR_RICserviceUpdate:
4430 DU_LOG("\nINFO --> E2AP : RIC Service update received");
4431 ProcRicServiceUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate);
4434 case InitiatingMessageE2__value_PR_RICsubscriptionModificationRequired:
4436 DU_LOG("\nINFO --> E2AP : RIC Subscription Modification Required");
4437 ProcRicSubsModReqd(*duId, \
4438 &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired);
4442 case InitiatingMessageE2__value_PR_ErrorIndicationE2:
4444 DU_LOG("\nINFO --> E2AP : Error indication received");
4449 DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]", \
4450 e2apMsg->choice.initiatingMessage->value.present);
4453 }/* End of switch(initiatingMessage) */
4456 case E2AP_PDU_PR_successfulOutcome:
4458 switch(e2apMsg->choice.successfulOutcome->value.present)
4460 case SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse:
4462 ProcRicSubscriptionResponse(*duId, \
4463 &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse);
4468 DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]", \
4469 e2apMsg->choice.successfulOutcome->value.present);
4476 case E2AP_PDU_PR_unsuccessfulOutcome:
4478 switch(e2apMsg->choice.successfulOutcome->value.present)
4480 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionFailure:
4482 ProcRicSubscriptionFailure(*duId, \
4483 &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure);
4488 DU_LOG("\nERROR --> E2AP : Invalid type of unsuccessfulOutcome message [%d]", \
4489 e2apMsg->choice.unsuccessfulOutcome->value.present);
4497 DU_LOG("\nERROR --> E2AP : Invalid type message type ");
4501 }/* End of switch(e2apMsg->present) */
4502 } /* End of E2APMsgHdlr */
4505 /**********************************************************************
4507 **********************************************************************/