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 Builds Global RIC Id Params
134 * Function : BuildGlobalRicId
136 * Functionality: Building the Plmn and ric id
138 * @params[in] GlobalRIC_ID_t *ricId
139 * @return ROK - success
142 * ****************************************************************/
144 uint8_t BuildGlobalRicId(GlobalRIC_ID_t *ricId)
147 uint8_t byteSize = 3;
151 ricId->pLMN_Identity.size = byteSize * sizeof(uint8_t);
152 RIC_ALLOC(ricId->pLMN_Identity.buf, ricId->pLMN_Identity.size);
153 buildPlmnId(ricCb.ricCfgParams.plmn , ricId->pLMN_Identity.buf);
155 ricId->ric_ID.size = byteSize * sizeof(uint8_t);
156 RIC_ALLOC(ricId->ric_ID.buf, ricId->ric_ID.size);
157 fillBitString(&ricId->ric_ID, unused, byteSize, ricVal);
162 /*******************************************************************
164 * @brief deallocate the memory allocated in E2SetupResponse
168 * Function : FreeE2SetupRsp
170 * Functionality: deallocate the memory allocated in E2SetupResponse
172 * @params[in] E2AP_PDU_t *e2apMsg
175 * ****************************************************************/
176 void FreeE2SetupRsp(E2AP_PDU_t *e2apMsg)
178 uint8_t arrIdx = 0, e2NodeConfigIdx=0, ranFuncIdx=0;
179 RANfunctionsID_List_t *ranFuncAcceptedList=NULL;
180 E2setupResponse_t *e2SetupRsp=NULL;
181 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItemIe=NULL;
182 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList=NULL;
183 E2nodeComponentInterfaceF1_t *f1InterfaceInfo=NULL;
187 if(e2apMsg->choice.successfulOutcome)
189 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
190 if(e2SetupRsp->protocolIEs.list.array)
192 for(arrIdx=0; arrIdx<e2SetupRsp->protocolIEs.list.count; arrIdx++)
194 switch(e2SetupRsp->protocolIEs.list.array[arrIdx]->id)
196 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
198 ranFuncAcceptedList= &e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
199 if(ranFuncAcceptedList->list.array)
201 for(ranFuncIdx=0;ranFuncIdx<ranFuncAcceptedList->list.count; ranFuncIdx++)
203 if(ranFuncAcceptedList->list.array[ranFuncIdx])
205 RIC_FREE(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
208 RIC_FREE(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
212 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
214 e2NodeConfigAdditionAckList =&e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
215 if(e2NodeConfigAdditionAckList->list.count)
217 for(e2NodeConfigIdx=0; e2NodeConfigIdx<e2NodeConfigAdditionAckList->list.count; e2NodeConfigIdx++)
219 e2NodeAddAckItemIe = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[e2NodeConfigIdx];
220 if(e2NodeAddAckItemIe)
222 f1InterfaceInfo = e2NodeAddAckItemIe->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
225 RIC_FREE(f1InterfaceInfo->gNB_DU_ID.buf, f1InterfaceInfo->gNB_DU_ID.size);
226 RIC_FREE(f1InterfaceInfo, sizeof(E2nodeComponentInterfaceF1_t));
228 RIC_FREE(e2NodeAddAckItemIe, sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
231 RIC_FREE(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
236 RIC_FREE(e2SetupRsp->protocolIEs.list.array[arrIdx], sizeof(E2setupResponseIEs_t));
238 RIC_FREE(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
240 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
242 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
246 /*******************************************************************
248 * @brief Build E2node Component config addition ack list
252 * Function : BuildE2nodeComponentConfigAdditionAck
254 * Functionality: deallocate the memory allocated in E2SetupResponse
256 * @params[in] E2nodeComponentConfigAdditionAck_List_t
257 * *e2NodeConfigAdditionAckList
259 * @return ROK - success
261 * ****************************************************************/
263 uint8_t BuildE2nodeComponentConfigAdditionAck(E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList, DuDb *duDb)
266 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem;
268 e2NodeConfigAdditionAckList->list.count = 1;
269 e2NodeConfigAdditionAckList->list.size = e2NodeConfigAdditionAckList->list.count * sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t*);
270 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
271 if(e2NodeConfigAdditionAckList->list.array == NULLP)
273 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
277 for(arrIdx = 0; arrIdx< e2NodeConfigAdditionAckList->list.count; arrIdx++)
279 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
280 if(e2NodeConfigAdditionAckList->list.array[arrIdx] == NULLP)
282 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
286 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[0];
287 e2NodeAddAckItem->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck_Item;
288 e2NodeAddAckItem->criticality = CriticalityE2_reject;
289 e2NodeAddAckItem->value.present = E2nodeComponentConfigAdditionAck_ItemIEs__value_PR_E2nodeComponentConfigAdditionAck_Item;
290 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentInterfaceType = duDb->e2NodeComponent.interfaceType;
292 /* >E2 Node Component ID */
293 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
294 RIC_ALLOC(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
295 sizeof(E2nodeComponentInterfaceF1_t));
296 if(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1 == NULLP)
298 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
301 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
302 RIC_ALLOC(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
303 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
305 if(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
307 DU_LOG("\nERROR -->list. E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
310 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0] = duDb->e2NodeComponent.componentId;
312 /* >E2 Node Component Configuration Acknowledge*/
313 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentConfigurationAck.updateOutcome = \
314 E2nodeComponentConfigurationAck__updateOutcome_success;
319 /*******************************************************************
321 * @brief Build RAN function accepted list
325 * Function : BuildRanFunctionAcceptedList
327 * Functionality: Build RAN function accepted list
328 * ->For ProcedureCodeE2_id_E2setup or ProcedureCodeE2_id_RICserviceQuery
329 * we add all the RAN Function list which is present in RIC database.
330 * ->For any other procedures, we just fill the RAN functions whose ID
331 * is present in the recvList
335 * Count of ran functions to be accepted in the list
336 * Received list of RAN functions
340 * @return ROK - success
342 * ****************************************************************/
344 uint8_t BuildRanFunctionAcceptedList(DuDb *duDb, uint8_t count, RanFunction *ranFunAcceptedList, RANfunctionsID_List_t *ranFuncAcceptedList, uint8_t procedureCode)
346 uint8_t ranFuncIdx = 0;
347 RANfunctionID_ItemIEs_t *ranFuncAcceptedItemIe=NULL;
349 /* For ProcedureCodeE2_id_E2setup and ProcedureCodeE2_id_RICserviceQuery,
350 * the number of RAN function list items is equal to the number of
351 * ran function entries stored in the database.
352 * For any other procedure, the RAN function list count is equal
353 * to the count of ran functions obtained from the function's caller */
355 if((procedureCode == ProcedureCodeE2_id_RICserviceQuery)||(procedureCode == ProcedureCodeE2_id_E2setup))
356 ranFuncAcceptedList->list.count = duDb->numOfRanFunction;
358 ranFuncAcceptedList->list.count = count;
360 ranFuncAcceptedList->list.size = ranFuncAcceptedList->list.count*sizeof(RANfunctionID_ItemIEs_t*);
361 RIC_ALLOC(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
362 if(ranFuncAcceptedList->list.array)
364 for(ranFuncIdx = 0; ranFuncIdx< ranFuncAcceptedList->list.count; ranFuncIdx++)
366 RIC_ALLOC(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
367 if(ranFuncAcceptedList->list.array[ranFuncIdx] == NULLP)
369 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array item");
372 ranFuncAcceptedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAcceptedList->list.array[ranFuncIdx];
373 ranFuncAcceptedItemIe->id = ProtocolIE_IDE2_id_RANfunctionID_Item;
374 ranFuncAcceptedItemIe->criticality= CriticalityE2_ignore;
375 ranFuncAcceptedItemIe->value.present = RANfunctionID_ItemIEs__value_PR_RANfunctionID_Item;
376 if((procedureCode == ProcedureCodeE2_id_RICserviceQuery)||(procedureCode == ProcedureCodeE2_id_E2setup))
378 /* filling the RAN function information with the help of DuDb */
379 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID = duDb->ranFunction[ranFuncIdx].id;
380 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision= duDb->ranFunction[ranFuncIdx].revisionCounter;
384 /* filling the the RAN function information with the help received list of RAN functions */
385 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID = ranFunAcceptedList[ranFuncIdx].id;
386 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision= ranFunAcceptedList[ranFuncIdx].revisionCounter;
392 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array");
398 /*******************************************************************
400 * @brief Builds and sends the E2SetupResponse
404 * Function : BuildAndSendE2SetupRsp
406 * Functionality: Constructs the F1SetupResponse message and sends
407 * it back to the DU through SCTP.
409 * @params[in] void **buf,Buffer to which encoded pattern is written into
410 * @params[in] int *size,size of buffer
412 * @return ROK - success
415 * ****************************************************************/
417 uint8_t BuildAndSendE2SetupRsp(DuDb *duDb, uint8_t transId)
419 E2AP_PDU_t *e2apMsg = NULL;
420 E2setupResponse_t *e2SetupRsp;
421 asn_enc_rval_t encRetVal;
424 bool memAllocFailed = false;
426 DU_LOG("\nINFO --> E2AP : Building E2 Setup Response\n");
429 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
432 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
435 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
436 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
437 if(e2apMsg->choice.successfulOutcome == NULLP)
439 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
443 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
444 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
445 e2apMsg->choice.successfulOutcome->value.present = \
446 SuccessfulOutcomeE2__value_PR_E2setupResponse;
447 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
450 /* Fill Accepted RAN function IE If Ran function information is stored in databse */
451 if(duDb->numOfRanFunction)
454 e2SetupRsp->protocolIEs.list.count = elementCnt;
455 e2SetupRsp->protocolIEs.list.size = elementCnt * sizeof(E2setupResponseIEs_t*);
457 RIC_ALLOC(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
458 if(e2SetupRsp->protocolIEs.list.array == NULLP)
460 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
464 for(idx=0; idx<elementCnt; idx++)
466 RIC_ALLOC(e2SetupRsp->protocolIEs.list.array[idx], sizeof(E2setupResponseIEs_t));
467 if(e2SetupRsp->protocolIEs.list.array[idx] == NULLP)
469 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
470 memAllocFailed = true;
475 if(memAllocFailed == true)
477 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
482 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_TransactionID;
483 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
484 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_TransactionID;
485 e2SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID = transId;
489 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_GlobalRIC_ID;
490 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
491 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_GlobalRIC_ID;
493 if(BuildGlobalRicId(&(e2SetupRsp->protocolIEs.list.array[idx]->value.choice.GlobalRIC_ID))!=ROK)
495 DU_LOG("\nERROR --> E2AP : Failed to build Global Ric Id");
499 if(duDb->numOfRanFunction)
501 /* Accepted RAN function Id */
503 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
504 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
505 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_RANfunctionsID_List;
506 if(BuildRanFunctionAcceptedList(duDb, 0, NULL, &e2SetupRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_E2setup)!=ROK)
508 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
513 /* E2 Node Component Configuration Addition Acknowledge List*/
515 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck;
516 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
517 e2SetupRsp->protocolIEs.list.array[idx]->value.present = \
518 E2setupResponseIEs__value_PR_E2nodeComponentConfigAdditionAck_List;
519 if(BuildE2nodeComponentConfigAdditionAck(&e2SetupRsp->protocolIEs.list.array[idx]->\
520 value.choice.E2nodeComponentConfigAdditionAck_List, duDb) != ROK)
522 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config addition ack list");
526 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
527 memset(encBuf, 0, ENC_BUF_MAX_LEN);
529 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
531 /* Check encode results */
532 if(encRetVal.encoded == ENCODE_FAIL)
534 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupResponse structure (at %s)\n",\
535 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
540 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupResponse\n");
541 for(int i=0; i< encBufSize; i++)
543 DU_LOG("%x",encBuf[i]);
547 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
549 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Response failed");
555 FreeE2SetupRsp(e2apMsg);
556 BuildAndSendRicSubscriptionReq(duDb);
560 /*******************************************************************
562 * @brief Free RIC Subscription Details
566 * Function : FreeRicSubsDetails
568 * Functionality: Free the RIC Subscription Details
570 * @params[in] RICsubscriptionDetails_t *subsDetails
573 * ****************************************************************/
574 void FreeRicSubsDetails(RICsubscriptionDetails_t *subsDetails)
576 uint8_t elementIdx = 0;
577 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
579 RIC_FREE(subsDetails->ricEventTriggerDefinition.buf, subsDetails->ricEventTriggerDefinition.size);
581 if(subsDetails->ricAction_ToBeSetup_List.list.array)
583 for(elementIdx = 0; elementIdx < subsDetails->ricAction_ToBeSetup_List.list.count; elementIdx++)
585 if(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
587 actionItem = (RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx];
588 if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
590 RIC_FREE(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf, \
591 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->size);
592 RIC_FREE(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
594 RIC_FREE(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], sizeof(RICaction_ToBeSetup_ItemIEs_t))
597 RIC_FREE(subsDetails->ricAction_ToBeSetup_List.list.array, subsDetails->ricAction_ToBeSetup_List.list.size);
601 /*******************************************************************
603 * @brief Free RIC Subscription Request
607 * Function : FreeRicSubscriptionReq
609 * Functionality : Free RIC Subscription Request
611 * @return ROK - success
614 ******************************************************************/
615 void FreeRicSubscriptionReq(E2AP_PDU_t *e2apRicMsg)
618 RICsubscriptionRequest_t *ricSubscriptionReq;
622 if(e2apRicMsg->choice.initiatingMessage)
624 ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
625 if(ricSubscriptionReq->protocolIEs.list.array)
627 for(idx=0; idx < ricSubscriptionReq->protocolIEs.list.count; idx++)
629 switch(ricSubscriptionReq->protocolIEs.list.array[idx]->id)
631 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
633 FreeRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails));
637 RIC_FREE(ricSubscriptionReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionRequest_IEs_t));
639 RIC_FREE(ricSubscriptionReq->protocolIEs.list.array, ricSubscriptionReq->protocolIEs.list.size);
641 RIC_FREE(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
643 RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
647 /*******************************************************************
649 * @brief Builds Ric Request Id
653 * Function : BuildNewRicRequestId
655 * Functionality: Assign new Ric Request ID
657 * @params[in] RIC request ID to be sent
658 * RIC request ID stored in DB
659 * @return ROK - success
662 * ****************************************************************/
664 uint8_t BuildNewRicRequestId(RICrequestID_t *ricReqId, RicRequestId *reqIdDb)
666 static uint16_t requestorId = 0;
667 static uint16_t instanceId = 0;
669 if(ricReqId != NULLP)
671 ricReqId->ricRequestorID = ++requestorId;
672 ricReqId->ricInstanceID = ++instanceId;
674 reqIdDb->requestorId = ricReqId->ricRequestorID;
675 reqIdDb->instanceId = ricReqId->ricInstanceID;
680 /*******************************************************************
682 * @brief Free RIC Action Definition
686 * Function : FreeRicActionDefinition
688 * Functionality: Free RIC Action Definition
690 * @params[in] E2SM-KPM Action definition
693 * ****************************************************************/
694 void FreeRicActionDefinition(E2SM_KPM_ActionDefinition_t actionDef)
696 uint8_t elementIdx = 0;
697 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
698 MeasurementInfoItem_t *measItem = NULLP;
700 switch(actionDef.actionDefinition_formats.present)
702 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
704 if(actionDef.actionDefinition_formats.choice.actionDefinition_Format1)
706 actionFormat1 = actionDef.actionDefinition_formats.choice.actionDefinition_Format1;
707 if(actionFormat1->measInfoList.list.array)
709 for(elementIdx = 0; elementIdx < actionFormat1->measInfoList.list.count; elementIdx++)
711 if(actionFormat1->measInfoList.list.array[elementIdx])
713 measItem = actionFormat1->measInfoList.list.array[elementIdx];
714 switch(measItem->measType.present)
716 case MeasurementType_PR_NOTHING:
717 case MeasurementType_PR_measID:
719 case MeasurementType_PR_measName:
721 RIC_FREE(measItem->measType.choice.measName.buf, measItem->measType.choice.measName.size)
725 RIC_FREE(measItem, sizeof(MeasurementInfoItem_t));
728 RIC_FREE(actionFormat1->measInfoList.list.array, actionFormat1->measInfoList.list.size);
730 RIC_FREE(actionFormat1, sizeof(E2SM_KPM_ActionDefinition_Format1_t));
735 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format2:
736 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format3:
737 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format4:
738 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format5:
739 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_NOTHING:
744 /*******************************************************************
746 * @brief Fill RIC Action Definition
750 * Function : fillRicActionDef
752 * Functionality: Fill RIC Action Definition
754 * @params[in] RIC Action definition
758 * ****************************************************************/
759 uint8_t fillRicActionDef(RICactionDefinition_t *ricActionDef)
761 uint8_t ret = RFAILED;
762 asn_enc_rval_t encRetVal;
763 uint8_t elementCnt = 0, elementIdx = 0;
764 char *measurementTypeName[] = {"RRU.PrbTotDl", "RRU.PrbTotUl"};
765 E2SM_KPM_ActionDefinition_t actionDef;
766 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
767 MeasurementInfoItem_t *measItem = NULLP;
771 /* Fill E2SM-KPM Action Definition Format 1 */
774 actionDef.ric_Style_Type = RIC_STYLE_TYPE;
776 /* RIC Action Definition Format 1 */
777 actionDef.actionDefinition_formats.present = \
778 E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1;
780 RIC_ALLOC(actionDef.actionDefinition_formats.choice.actionDefinition_Format1, \
781 sizeof(E2SM_KPM_ActionDefinition_Format1_t));
782 if(actionDef.actionDefinition_formats.choice.actionDefinition_Format1 == NULLP)
784 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
787 actionFormat1 = actionDef.actionDefinition_formats.choice.actionDefinition_Format1;
789 /* Measurement Info List */
791 actionFormat1->measInfoList.list.count = elementCnt;
792 actionFormat1->measInfoList.list.size = elementCnt * sizeof(MeasurementInfoItem_t *);
793 RIC_ALLOC(actionFormat1->measInfoList.list.array, actionFormat1->measInfoList.list.size);
794 if(actionFormat1->measInfoList.list.array == NULL)
796 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
800 for(elementIdx = 0; elementIdx < elementCnt; elementIdx++)
802 RIC_ALLOC(actionFormat1->measInfoList.list.array[elementIdx], sizeof(MeasurementInfoItem_t));
803 if(actionFormat1->measInfoList.list.array[elementIdx] == NULLP)
805 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
809 measItem = actionFormat1->measInfoList.list.array[elementIdx];
810 measItem->measType.present = MeasurementType_PR_measName;
812 measItem->measType.choice.measName.size = strlen(measurementTypeName[elementIdx]);
813 RIC_ALLOC(measItem->measType.choice.measName.buf, measItem->measType.choice.measName.size);
814 if(measItem->measType.choice.measName.buf == NULLP)
816 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
819 memcpy(measItem->measType.choice.measName.buf, measurementTypeName[elementIdx], measItem->measType.choice.measName.size);
821 if(elementIdx < elementCnt)
824 /* Granularity Period */
825 actionFormat1->granulPeriod = RIC_ACTION_GRANULARITY_PERIOD; /* In ms */
827 /* Prints the Msg formed */
828 xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, &actionDef);
830 /* Encode E2SM-KPM RIC Action Definition */
831 memset(encBuf, 0, ENC_BUF_MAX_LEN);
833 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_ActionDefinition, 0, &actionDef, PrepFinalEncBuf, encBuf);
834 if(encRetVal.encoded == ENCODE_FAIL)
836 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM action definition structure (at %s)\n",\
837 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
841 /* Copty encoded E2SM-KPM RIC action definition to E2AP octet string buffer */
842 ricActionDef->size = encBufSize;
843 RIC_ALLOC(ricActionDef->buf, encBufSize);
844 if(ricActionDef->buf == NULLP)
846 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
849 memcpy(ricActionDef->buf, encBuf, encBufSize);
855 FreeRicActionDefinition(actionDef);
859 /*******************************************************************
861 * @brief Fills RIC Action To Be Setup Item
865 * Function : fillActionToBeSetup
867 * Functionality: Fill the RIC Action To Be Setup Ite,
868 * RIC subscription DB
870 * @params[in] RICaction_ToBeSetup_ItemIEs_t *items
871 * @return ROK - success
874 * ****************************************************************/
875 uint8_t fillActionToBeSetup(RICaction_ToBeSetup_ItemIEs_t *actionItem, RicSubscription *ricSubsDb)
877 static uint8_t ricActionId = 0;
879 if(actionItem == NULLP)
881 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
887 actionItem->id = ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item;
888 actionItem->criticality = CriticalityE2_ignore;
889 actionItem->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
892 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID = ++ricActionId;
893 ricSubsDb->actionSequence[ricSubsDb->numOfActions].id = \
894 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID;
896 /* RIC Action Type */
897 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType = RICactionType_report;
899 /* RIC Action Definition */
900 RIC_ALLOC(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, sizeof(RICactionDefinition_t));
901 if(!actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
903 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
906 if(fillRicActionDef(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition) != ROK)
908 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
912 ricSubsDb->numOfActions++;
916 memset(&ricSubsDb->actionSequence[ricSubsDb->numOfActions], 0, sizeof(ActionInfo));
920 /*******************************************************************
922 * @brief Free Event Trigger Definition
926 * Function : FreeEventTriggerDef
928 * Functionality: Free Event Trigger Definition
930 * @params[in] E2SM-KPM Event Trigger Definition
933 * ****************************************************************/
934 void FreeEventTriggerDef(E2SM_KPM_EventTriggerDefinition_t *eventTiggerDef)
938 switch(eventTiggerDef->eventDefinition_formats.present)
940 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING:
942 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1:
943 RIC_FREE(eventTiggerDef->eventDefinition_formats.choice.eventDefinition_Format1, \
944 sizeof(E2SM_KPM_EventTriggerDefinition_Format1_t));
950 /*******************************************************************
952 * @brief Fill Event Trigger Definition
956 * Function : fillEventTriggerDef
958 * Functionality: Fill Event Trigger Definition
960 * @params[in] RIC Event Trigger Definition
964 * ****************************************************************/
965 uint8_t fillEventTriggerDef(RICeventTriggerDefinition_t *ricEventTriggerDef)
967 uint8_t ret = RFAILED;
968 asn_enc_rval_t encRetVal;
969 E2SM_KPM_EventTriggerDefinition_t eventTiggerDef;
973 /* Fill E2SM-KPM Event Trigger Definition Format 1 */
974 eventTiggerDef.eventDefinition_formats.present = \
975 E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1;
977 RIC_ALLOC(eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1, \
978 sizeof(E2SM_KPM_EventTriggerDefinition_Format1_t));
979 if(eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1 == NULLP)
981 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
985 eventTiggerDef.eventDefinition_formats.choice.eventDefinition_Format1->reportingPeriod = 1000; /* In ms */
987 /* Prints the Msg formed */
988 xer_fprint(stdout, &asn_DEF_E2SM_KPM_EventTriggerDefinition, &eventTiggerDef);
990 /* Encode E2SM-KPM Event Trigger Definition */
991 memset(encBuf, 0, ENC_BUF_MAX_LEN);
993 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_EventTriggerDefinition, 0, &eventTiggerDef, PrepFinalEncBuf, encBuf);
994 if(encRetVal.encoded == ENCODE_FAIL)
996 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM event trigger definition structure (at %s)\n",\
997 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1001 /* Copy encoded E2SM-KPM event trigger definition to E2AP octet string buffer */
1002 ricEventTriggerDef->size = encBufSize;
1003 RIC_ALLOC(ricEventTriggerDef->buf, encBufSize);
1004 if(ricEventTriggerDef->buf == NULLP)
1006 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1009 memcpy(ricEventTriggerDef->buf, encBuf, encBufSize);
1015 FreeEventTriggerDef(&eventTiggerDef);
1019 /*******************************************************************
1021 * @brief builds RIC Subscription Details
1025 * Function : BuildsRicSubsDetails
1027 * Functionality: Builds the RIC Subscription Details
1029 * @params[in] RIC Subscription details to be filled
1030 * RIC subscriotion DB
1031 * @return ROK - success
1034 * ****************************************************************/
1036 uint8_t BuildRicSubsDetails(RICsubscriptionDetails_t *subsDetails, RicSubscription *ricSubsDb)
1038 uint8_t elementCnt = 0;
1039 uint8_t elementIdx = 0;
1041 if(subsDetails == NULLP)
1043 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
1049 /* RIC Event Trigger Definition */
1050 if(fillEventTriggerDef(&subsDetails->ricEventTriggerDefinition) != ROK)
1052 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
1056 /* RIC Actions To Be Setup List */
1058 subsDetails->ricAction_ToBeSetup_List.list.count = elementCnt;
1059 subsDetails->ricAction_ToBeSetup_List.list.size = elementCnt * sizeof(RICaction_ToBeSetup_ItemIEs_t *);
1060 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array, subsDetails->ricAction_ToBeSetup_List.list.size);
1061 if(subsDetails->ricAction_ToBeSetup_List.list.array == NULLP)
1063 DU_LOG("\nERROR --> E2AP : Memory allocation for RICactionToBeSetup Items failed");
1067 for(elementIdx = 0; elementIdx < elementCnt; elementIdx++)
1069 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], sizeof(RICaction_ToBeSetup_ItemIEs_t));
1070 if(!subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
1072 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1076 if(elementIdx < elementCnt)
1080 if(fillActionToBeSetup((RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx], \
1083 DU_LOG("\nERROR --> E2AP : Failed at [%s] : line [%d]", __func__, __LINE__);
1092 /*******************************************************************
1094 * @brief Builds and Send the RicSubscriptionReq
1098 * Function : BuildAndSendRicSubscriptionReq
1100 * Functionality:Fills the RicSubscriptionReq
1102 * @return ROK - success
1105 ******************************************************************/
1106 uint8_t BuildAndSendRicSubscriptionReq(DuDb *duDb)
1108 uint8_t ret = RFAILED;
1109 E2AP_PDU_t *e2apRicMsg = NULL;
1110 RICsubscriptionRequest_t *ricSubscriptionReq;
1114 asn_enc_rval_t encRetVal; /* Encoder return value */
1115 RanFunction *ranFuncDb = &duDb->ranFunction[0];
1117 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Request\n");
1121 RIC_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
1122 if(e2apRicMsg == NULLP)
1124 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1128 e2apRicMsg->present = E2AP_PDU_PR_initiatingMessage;
1129 RIC_ALLOC(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1130 if(e2apRicMsg->choice.initiatingMessage == NULLP)
1132 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1135 e2apRicMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscription;
1136 e2apRicMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
1137 e2apRicMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionRequest;
1139 ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
1142 ricSubscriptionReq->protocolIEs.list.count = elementCnt;
1143 ricSubscriptionReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionRequest_IEs_t);
1145 /* Initialize the subscription members */
1146 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array, ricSubscriptionReq->protocolIEs.list.size);
1147 if(ricSubscriptionReq->protocolIEs.list.array == NULLP)
1149 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1153 for(idx=0; idx<elementCnt; idx++)
1155 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionRequest_IEs_t));
1156 if(ricSubscriptionReq->protocolIEs.list.array[idx] == NULLP)
1158 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1162 if(idx < elementCnt)
1165 /* Filling RIC Request Id */
1167 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
1168 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1169 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
1170 RICsubscriptionRequest_IEs__value_PR_RICrequestID;
1171 if(BuildNewRicRequestId(&ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICrequestID, \
1172 &ranFuncDb->subscriptionList[ranFuncDb->numOfSubscription].requestId) != ROK)
1174 DU_LOG("\nERROR --> E2AP : Failed at [%d] : Line [%d]", __func__, __LINE__);
1179 /* Filling RAN Function Id */
1181 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
1182 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1183 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
1184 RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
1185 ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID = ranFuncDb->id;
1187 /* Filling RIC Subscription Details */
1189 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICsubscriptionDetails;
1190 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1191 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
1192 RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails;
1193 if(BuildRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails),\
1194 &ranFuncDb->subscriptionList[ranFuncDb->numOfSubscription]) != ROK)
1196 DU_LOG("\nERROR --> E2AP : Failed at [%d] : Line [%d]", __func__, __LINE__);
1200 /* Prints the Msg formed */
1201 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
1203 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1205 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf);
1206 if(encRetVal.encoded == ENCODE_FAIL)
1208 DU_LOG("\nERROR --> E2AP : Could not encode RicSubscriptionRequest structure (at %s)\n",\
1209 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1214 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionRequest\n");
1215 for(int i=0; i< encBufSize; i++)
1217 DU_LOG("%x",encBuf[i]);
1222 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
1224 DU_LOG("\nERROR --> E2AP : Sending RIC subscription Request failed");
1228 ranFuncDb->numOfSubscription++;
1234 memset(&ranFuncDb->subscriptionList[ranFuncDb->numOfSubscription], 0, sizeof(RicSubscription));
1235 FreeRicSubscriptionReq(e2apRicMsg);
1239 /*******************************************************************
1241 * @brief Process RicSubscriptionResponse
1245 * Function : ProcRicSubscriptionRsp
1247 * Functionality: Processes RicSubscriptionRsp
1249 * @return ROK - void
1251 ******************************************************************/
1253 void ProcRicSubscriptionResponse(uint32_t duId)
1258 DU_LOG("\nINFO --> E2AP : RICsubscriptionResponse Msg Acknowledged");
1260 SEARCH_DU_DB(duIdx, duId, duDb);
1262 duDb->ricSubscribedToDu = true;
1265 /*******************************************************************
1267 * @brief deallocate the memory allocated in E2SetupFailure
1271 * Function : FreeE2SetupFailure
1273 * Functionality: deallocate the memory allocated in E2SetupFailure
1275 * @params[in] E2AP_PDU_t *e2apMsg
1278 * ****************************************************************/
1279 void FreeE2SetupFailure(E2AP_PDU_t *e2apMsg)
1282 E2setupFailure_t *e2SetupFail;
1286 if(e2apMsg->choice.unsuccessfulOutcome)
1288 e2SetupFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
1289 if(e2SetupFail->protocolIEs.list.array)
1291 for(arrIdx=0; arrIdx<e2SetupFail->protocolIEs.list.count; arrIdx++)
1293 RIC_FREE(e2SetupFail->protocolIEs.list.array[arrIdx], sizeof(E2setupFailureIEs_t));
1295 RIC_FREE(e2SetupFail->protocolIEs.list.array, e2SetupFail->protocolIEs.list.size);
1297 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
1299 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1303 /*******************************************************************
1305 * @brief Buld and send the E2 Setup failure
1309 * Function : BuildAndSendE2SetupFailure
1312 * - Buld and send the E2 Setup failure
1313 * @return ROK - success
1316 * ****************************************************************/
1318 uint8_t BuildAndSendE2SetupFailure(uint32_t duId, uint8_t transId)
1320 E2AP_PDU_t *e2apMsg = NULL;
1321 E2setupFailure_t *e2SetupFailure;
1322 asn_enc_rval_t encRetVal;
1325 bool memAllocFailed = false;
1327 DU_LOG("\nINFO --> E2AP : Building E2 Setup failure\n");
1330 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1331 if(e2apMsg == NULLP)
1333 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1336 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
1337 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
1338 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
1340 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1344 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
1345 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
1346 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2setupFailure;
1347 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
1350 e2SetupFailure->protocolIEs.list.count = elementCnt;
1351 e2SetupFailure->protocolIEs.list.size = elementCnt * sizeof(struct E2setupFailureIEs *);
1353 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array, e2SetupFailure->protocolIEs.list.size);
1354 if(e2SetupFailure->protocolIEs.list.array == NULLP)
1356 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
1360 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
1362 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array[arrIdx], sizeof(struct E2setupFailureIEs));
1363 if(e2SetupFailure->protocolIEs.list.array[arrIdx] == NULLP)
1365 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
1366 memAllocFailed = true;
1371 if(memAllocFailed == true)
1373 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
1379 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1380 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1381 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID;
1382 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
1385 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
1386 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1387 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2;
1388 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = CauseE2_PR_protocol;
1389 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.protocol = CauseE2Protocol_unspecified;
1392 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
1393 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
1394 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2;
1395 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
1397 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1398 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1400 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
1402 /* Check encode results */
1403 if(encRetVal.encoded == ENCODE_FAIL)
1405 DU_LOG("\nERROR --> E2AP : Could not encode E2 Setup failure structure (at %s)\n",\
1406 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1411 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Setup Failure\n");
1412 for(int i=0; i< encBufSize; i++)
1414 DU_LOG("%x",encBuf[i]);
1418 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
1420 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Failure failed");
1426 FreeE2SetupFailure(e2apMsg);
1429 /*******************************************************************
1431 * @brief process the e2setup request
1435 * Function : ProcE2SetupReq
1437 * Functionality: process the e2setup request
1439 * @return ROK - success
1442 ******************************************************************/
1444 uint8_t ProcE2SetupReq(uint32_t *duId, E2setupRequest_t *e2SetupReq)
1446 uint8_t arrIdx = 0, e2NodeAddListIdx =0, duIdx = 0, transId =0, ranFuncIdx;
1448 E2nodeComponentConfigAddition_List_t *e2NodeAddList;
1449 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem;
1450 RANfunction_ItemIEs_t *ranFuncItemIe;
1451 RANfunction_Item_t *ranFunItem;
1452 RANfunctions_List_t *ranFunctionsList;
1456 if(e2SetupReq->protocolIEs.list.array)
1458 for(arrIdx=0; arrIdx<e2SetupReq->protocolIEs.list.count; arrIdx++)
1460 if(e2SetupReq->protocolIEs.list.array[arrIdx])
1462 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
1464 case ProtocolIE_IDE2_id_TransactionID:
1466 transId = e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
1469 case ProtocolIE_IDE2_id_GlobalE2node_ID:
1471 if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID)
1473 *duId =e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID->buf[0];
1475 SEARCH_DU_DB(duIdx, *duId, duDb);
1478 duDb = &ricCb.duInfo[ricCb.numDu];
1481 memset(duDb, 0, sizeof(DuDb));
1486 case ProtocolIE_IDE2_id_RANfunctionsAdded:
1488 ranFunctionsList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
1490 if(ranFunctionsList->list.array)
1492 for(ranFuncIdx=0;ranFuncIdx<ranFunctionsList->list.count; ranFuncIdx++)
1494 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
1495 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
1496 duDb->ranFunction[duDb->numOfRanFunction].id = ranFunItem->ranFunctionID;
1497 duDb->ranFunction[duDb->numOfRanFunction].revisionCounter = ranFunItem->ranFunctionRevision;
1498 duDb->numOfRanFunction++;
1503 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
1505 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
1506 if(e2NodeAddList->list.array)
1508 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
1510 if(e2NodeAddList->list.array[e2NodeAddListIdx])
1513 (E2nodeComponentConfigAddition_ItemIEs_t *)e2NodeAddList->list.array[e2NodeAddListIdx];
1514 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.\
1515 choice.e2nodeComponentInterfaceTypeF1)
1517 duDb->e2NodeComponent.interfaceType = F1;
1518 duDb->e2NodeComponent.componentId = \
1519 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.\
1520 choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0];
1535 if(BuildAndSendE2SetupRsp(duDb, transId) !=ROK)
1537 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 setup response");
1543 /*******************************************************************
1545 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
1549 * Function : FreeE2NodeConfigUpdate
1552 * - freeing the memory allocated for E2nodeConfigurationUpdate
1554 * @params[in] E2AP_PDU_t *e2apMsg
1555 * @return ROK - success
1558 * ****************************************************************/
1559 void FreeE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg)
1562 E2nodeConfigurationUpdate_t *e2NodeConfigUpdateAck;
1564 if(e2apMsg != NULLP)
1566 if(e2apMsg->choice.successfulOutcome != NULLP)
1568 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
1569 if(e2NodeConfigUpdateAck->protocolIEs.list.array != NULLP)
1571 for(arrIdx = 0; arrIdx < e2NodeConfigUpdateAck->protocolIEs.list.count; arrIdx++)
1573 RIC_FREE(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_t));
1575 RIC_FREE(e2NodeConfigUpdateAck->protocolIEs.list.array, e2NodeConfigUpdateAck->protocolIEs.list.size);
1577 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1579 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1583 /*******************************************************************
1585 * @brief Buld and send the E2 node config update msg
1589 * Function : BuildAndSendE2NodeConfigUpdate
1592 * - Buld and send the E2 node config update msg
1593 * @return ROK - success
1596 * ****************************************************************/
1598 uint8_t BuildAndSendE2NodeConfigUpdateAck(uint32_t duId)
1600 uint8_t arrIdx = 0,elementCnt = 1;
1602 E2AP_PDU_t *e2apMsg = NULLP;
1603 E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck = NULLP;
1604 asn_enc_rval_t encRetVal; /* Encoder return value */
1606 DU_LOG("\nINFO --> E2AP : Building E2 Node config update Ack Message\n");
1609 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1610 if(e2apMsg == NULLP)
1612 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1615 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
1616 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1617 if(e2apMsg->choice.successfulOutcome == NULLP)
1619 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1620 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1624 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
1625 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
1626 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge;
1627 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
1629 e2NodeConfigUpdateAck->protocolIEs.list.count = elementCnt;
1630 e2NodeConfigUpdateAck->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t*);
1631 /* Initialize the Ric Indication members */
1632 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array, \
1633 e2NodeConfigUpdateAck->protocolIEs.list.size);
1634 if(e2NodeConfigUpdateAck->protocolIEs.list.array == NULLP)
1636 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdateAck failed");
1640 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
1642 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t));
1643 if(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
1646 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdateAck failed");
1653 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1654 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1655 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_TransactionID;
1656 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = TRANS_ID;
1659 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1661 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1663 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1665 if(encRetVal.encoded == ENCODE_FAIL)
1667 DU_LOG("\nERROR --> E2AP : Could not encode E2 Node config update ack structure (at %s)\n",\
1668 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1673 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node config update ack \n");
1674 for(int i=0; i< encBufSize; i++)
1676 DU_LOG("%x",encBuf[i]);
1682 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
1684 DU_LOG("\nERROR --> E2AP : Failed to send E2 Node config update ack ");
1691 FreeE2NodeConfigUpdateAck(e2apMsg);
1695 /*******************************************************************
1697 * @brief Deallocate the memory allocated for E2 Reset Response
1701 * Function : FreeE2ResetResponse
1704 * - freeing the memory allocated for E2ResetResponse
1706 * @params[in] E2AP_PDU_t *e2apMsg
1707 * @return ROK - success
1710 * ****************************************************************/
1711 void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
1714 ResetResponseE2_t *resetResponse;
1716 if(e2apMsg != NULLP)
1718 if(e2apMsg->choice.successfulOutcome != NULLP)
1720 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
1721 if(resetResponse->protocolIEs.list.array)
1723 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
1725 if(resetResponse->protocolIEs.list.array[ieIdx])
1727 RIC_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
1730 RIC_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
1732 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1734 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1738 /*******************************************************************
1740 * @brief Buld and send the E2 Reset Response msg
1744 * Function : BuildAndSendE2ResetResponse
1747 * - Buld and send the E2 Reset Response Message
1748 * @return ROK - success
1751 * ****************************************************************/
1752 uint8_t BuildAndSendResetResponse(uint32_t duId, uint8_t transId)
1754 uint8_t ieIdx = 0, elementCnt = 0;
1755 uint8_t ret = RFAILED;
1756 E2AP_PDU_t *e2apMsg = NULLP;
1757 ResetResponseE2_t *resetResponse;
1758 asn_enc_rval_t encRetVal; /* Encoder return value */
1760 DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
1763 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1764 if(e2apMsg == NULLP)
1766 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
1769 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
1771 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1772 if(e2apMsg->choice.successfulOutcome == NULLP)
1774 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
1775 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1779 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset;
1780 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
1781 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2;
1782 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
1785 resetResponse->protocolIEs.list.count = elementCnt;
1786 resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *);
1787 RIC_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
1788 if(!resetResponse->protocolIEs.list.array)
1790 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
1794 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
1796 RIC_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
1797 if(!resetResponse->protocolIEs.list.array[ieIdx])
1799 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
1803 if(ieIdx < elementCnt)
1807 resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1808 resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
1809 resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID;
1810 resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
1812 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1814 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1816 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
1817 if(encRetVal.encoded == ENCODE_FAIL)
1819 DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
1820 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1825 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
1826 for(int i=0; i< encBufSize; i++)
1828 DU_LOG("%x",encBuf[i]);
1833 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
1835 DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
1843 FreeE2ResetResponse(e2apMsg);
1847 /*******************************************************************
1849 * @brief process the E2 Reset Request
1853 * Function : ProcE2ResetReq
1855 * Functionality: Process E2 Reset Request
1857 * @return ROK - success
1860 ******************************************************************/
1862 uint8_t ProcE2ResetReq(uint32_t duId, ResetRequestE2_t *resetReq)
1864 uint8_t ieIdx = 0, duIdx = 0;
1865 uint8_t transId = 0, cause = 0;
1870 if(resetReq->protocolIEs.list.array)
1872 for(ieIdx=0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
1874 if(resetReq->protocolIEs.list.array[ieIdx])
1876 switch(resetReq->protocolIEs.list.array[ieIdx]->id)
1878 case ProtocolIE_IDE2_id_TransactionID:
1879 transId = resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
1881 case ProtocolIE_IDE2_id_CauseE2:
1882 DU_LOG("\nDEBUG --> E2AP : Reset reason %d", resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present);
1883 switch(resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present)
1885 case CauseE2_PR_NOTHING:
1887 case CauseE2_PR_ricRequest:
1888 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricRequest;
1890 case CauseE2_PR_ricService:
1891 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricService;
1893 case CauseE2_PR_e2Node:
1894 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.e2Node;
1896 case CauseE2_PR_transport:
1897 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.transport;
1899 case CauseE2_PR_protocol:
1900 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.protocol;
1902 case CauseE2_PR_misc:
1903 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.misc;
1906 DU_LOG("\nDEBUG --> E2AP : Reset cause %d", cause);
1913 BuildAndSendResetResponse(duId, transId);
1917 /*******************************************************************
1919 * @brief deallocate the memory allocated in building the
1920 * Service Query message
1924 * Function : FreeRicServiceQuery
1926 * Functionality: deallocate the memory allocated in building
1927 * Ric Service Query message
1929 * @params[in] E2AP_PDU_t *e2apMsg
1932 * ****************************************************************/
1934 void FreeRicServiceQuery(E2AP_PDU_t *e2apMsg)
1936 uint8_t arrIdx = 0, ranFuncIdx=0;
1937 RANfunctionsID_List_t *ranFuncAcceptedList=NULL;
1938 RICserviceQuery_t *ricServiceQuery=NULL;
1942 if(e2apMsg->choice.initiatingMessage)
1944 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
1945 if(ricServiceQuery->protocolIEs.list.array)
1947 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
1949 if(ricServiceQuery->protocolIEs.list.array[arrIdx])
1951 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
1953 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
1955 ranFuncAcceptedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
1956 if(ranFuncAcceptedList->list.array)
1958 for(ranFuncIdx=0;ranFuncIdx<ranFuncAcceptedList->list.count; ranFuncIdx++)
1960 RIC_FREE(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
1962 RIC_FREE(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
1966 case RICserviceQuery_IEs__value_PR_TransactionID:
1971 RIC_FREE(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
1974 RIC_FREE(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
1976 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1978 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1982 /*******************************************************************
1984 * @brief build and send the ric service Query
1988 * Function : BuildAndSendRicServiceQuery
1990 * Functionality: build and send the ric service Query
1991 * @return ROK - success
1992 * RFAILED - Acknowledge
1994 ******************************************************************/
1996 uint8_t BuildAndSendRicServiceQuery(DuDb *duDb)
2000 uint8_t ret = RFAILED;
2001 bool memAllocFailed = false;
2002 E2AP_PDU_t *e2apMsg = NULL;
2003 asn_enc_rval_t encRetVal;
2004 RICserviceQuery_t *ricServiceQuery;
2006 DU_LOG("\nINFO --> E2AP : Building Ric service Query\n");
2009 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2010 if(e2apMsg == NULLP)
2012 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2015 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
2016 RIC_ALLOC(e2apMsg->choice.initiatingMessage , sizeof(struct InitiatingMessageE2));
2017 if(e2apMsg->choice.initiatingMessage == NULLP)
2019 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2023 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceQuery;
2024 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
2025 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceQuery;
2026 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
2029 /* Fill Accepted RAN function IE If Ran function information is stored in databse */
2030 if(duDb->numOfRanFunction)
2033 ricServiceQuery->protocolIEs.list.count = elementCnt;
2034 ricServiceQuery->protocolIEs.list.size = elementCnt * sizeof(RICserviceQuery_IEs_t*);
2036 RIC_ALLOC(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
2037 if(ricServiceQuery->protocolIEs.list.array == NULLP)
2039 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
2043 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
2045 RIC_ALLOC(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
2046 if(ricServiceQuery->protocolIEs.list.array[arrIdx] == NULLP)
2048 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
2049 memAllocFailed = true;
2053 if(memAllocFailed == true)
2055 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
2061 ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2062 ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2063 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_TransactionID;
2064 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = assignTransactionId(duDb);
2066 if(duDb->numOfRanFunction)
2068 /* Accepted RAN function Id */
2070 ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
2071 ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2072 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_RANfunctionsID_List;
2073 if(BuildRanFunctionAcceptedList(duDb, 0, NULL, &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceQuery)!=ROK)
2075 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
2080 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2081 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2083 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2085 /* Check encode results */
2086 if(encRetVal.encoded == ENCODE_FAIL)
2088 DU_LOG("\nERROR --> E2AP : Could not encode RIC service Query structure (at %s)\n",\
2089 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2094 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service Query\n");
2095 for(int i=0; i< encBufSize; i++)
2097 DU_LOG("%x",encBuf[i]);
2101 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
2103 DU_LOG("\nERROR --> E2AP : Sending of RIC service Query failed");
2110 FreeRicServiceQuery(e2apMsg);
2114 /*******************************************************************
2116 * @brief deallocate the memory allocated in RicServiceUpdateFailure
2120 * Function : FreeRicServiceUpdateFailure
2122 * Functionality: deallocate the memory allocated in RicServiceUpdatefailure
2124 * @params[in] E2AP_PDU_t *e2apMsg
2127 * ****************************************************************/
2129 void FreeRicServiceUpdateFailure(E2AP_PDU_t *e2apMsg)
2132 RICserviceUpdateFailure_t *ricServiceUpdateFailure=NULL;
2136 if(e2apMsg->choice.unsuccessfulOutcome)
2138 ricServiceUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
2139 if(ricServiceUpdateFailure->protocolIEs.list.array)
2141 for(arrIdx=0; arrIdx<ricServiceUpdateFailure->protocolIEs.list.count; arrIdx++)
2143 RIC_FREE(ricServiceUpdateFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t));
2145 RIC_FREE(ricServiceUpdateFailure->protocolIEs.list.array, ricServiceUpdateFailure->protocolIEs.list.size);
2147 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
2149 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2153 /*******************************************************************
2155 * @brief fill E2 failure cause
2159 * Function : fillE2FailureCause
2161 * Functionality: fill E2 failure cause
2162 * @return ROK - success
2165 ******************************************************************/
2167 void fillE2FailureCause(CauseE2_t *cause, CauseE2_PR causePresent, uint8_t reason)
2169 cause->present = causePresent;
2171 switch(cause->present)
2173 case CauseE2_PR_ricRequest:
2174 cause->choice.ricRequest = reason;
2176 case CauseE2_PR_ricService:
2177 cause->choice.ricService = reason;
2179 case CauseE2_PR_e2Node:
2180 cause->choice.e2Node = reason;
2182 case CauseE2_PR_transport:
2183 cause->choice.transport = reason;
2185 case CauseE2_PR_protocol:
2186 cause->choice.protocol = reason;
2188 case CauseE2_PR_misc:
2189 cause->choice.misc = reason;
2192 cause->choice.misc = CauseE2Misc_unspecified;
2197 /*******************************************************************
2199 * @brief build and send the ric service update failure
2203 * Function : BuildAndSendRicServiceUpdateFailure
2205 * Functionality: build and send the ric service update failure
2206 * @return ROK - success
2209 ******************************************************************/
2211 uint8_t BuildAndSendRicServiceUpdateFailure(uint32_t duId, int8_t transId, CauseE2_PR causePresent, uint8_t reason)
2214 E2AP_PDU_t *e2apMsg = NULL;
2215 asn_enc_rval_t encRetVal;
2216 uint8_t ret = RFAILED;
2218 uint8_t elementCnt=0;
2219 RICserviceUpdateFailure_t *ricServiceFailure=NULL;
2221 DU_LOG("\nINFO --> E2AP : Building Ric service update failure\n");
2224 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2225 if(e2apMsg == NULLP)
2227 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2230 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
2231 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
2232 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
2234 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2238 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
2239 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
2240 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure;
2241 ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
2244 ricServiceFailure->protocolIEs.list.count = elementCnt;
2245 ricServiceFailure->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdateFailure_IEs_t *);
2247 RIC_ALLOC(ricServiceFailure->protocolIEs.list.array, ricServiceFailure->protocolIEs.list.size);
2248 if(ricServiceFailure->protocolIEs.list.array == NULLP)
2250 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
2254 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
2256 RIC_ALLOC(ricServiceFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t));
2257 if(ricServiceFailure->protocolIEs.list.array[arrIdx] == NULLP)
2259 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
2263 if(arrIdx<elementCnt)
2265 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
2271 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2272 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2273 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_TransactionID;
2274 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
2277 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
2278 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2279 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_CauseE2;
2280 fillE2FailureCause(&ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, causePresent, reason);
2283 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
2284 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
2285 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_TimeToWaitE2;
2286 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
2288 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2289 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2291 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2293 /* Check encode results */
2294 if(encRetVal.encoded == ENCODE_FAIL)
2296 DU_LOG("\nERROR --> E2AP : Could not encode RIC service update failure structure (at %s)\n",\
2297 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2302 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Failure\n");
2303 for(int i=0; i< encBufSize; i++)
2305 DU_LOG("%x",encBuf[i]);
2309 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
2311 DU_LOG("\nERROR --> E2AP : Sending RIC service update failed");
2318 FreeRicServiceUpdateFailure(e2apMsg);
2323 /*******************************************************************
2325 * @brief deallocate the memory allocated in RicServiceUpdateAck(
2329 * Function : FreeRicServiceUpdateAck
2331 * Functionality: deallocate the memory allocated in RicServiceUpdateAck
2333 * @params[in] E2AP_PDU_t *e2apMsg
2336 * ****************************************************************/
2338 void FreeRicServiceUpdateAck(E2AP_PDU_t *e2apMsg)
2340 uint8_t arrIdx = 0, ranFuncIdx=0;
2341 RANfunctionsID_List_t *acceptedList=NULL;
2342 RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL;
2343 RANfunctionsIDcause_List_t *rejectedList=NULL;
2347 if(e2apMsg->choice.successfulOutcome)
2349 ricServiceUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
2350 if(ricServiceUpdateAck->protocolIEs.list.array)
2352 for(arrIdx=0; arrIdx<ricServiceUpdateAck->protocolIEs.list.count; arrIdx++)
2354 if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx])
2356 switch(ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id)
2358 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
2360 acceptedList= &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
2361 if(acceptedList->list.array)
2363 for(ranFuncIdx=0;ranFuncIdx<acceptedList->list.count; ranFuncIdx++)
2365 RIC_FREE(acceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
2367 RIC_FREE(acceptedList->list.array, acceptedList->list.size);
2372 case ProtocolIE_IDE2_id_RANfunctionsRejected:
2374 rejectedList= &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
2375 if(rejectedList->list.array)
2377 for(ranFuncIdx=0;ranFuncIdx<rejectedList->list.count; ranFuncIdx++)
2379 RIC_FREE(rejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t));
2381 RIC_FREE(rejectedList->list.array, rejectedList->list.size);
2386 RIC_FREE(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t));
2389 RIC_FREE(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size);
2391 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2393 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2397 /*******************************************************************
2399 * @brief Build RAN function rejected list
2403 * Function : BuildRanFunctionRejectedList
2405 * Functionality: Build RAN function rejected list
2408 * Count of ran functions to be rejected in the list
2409 * Received list of RAN functions
2411 * @return ROK - success
2413 * ****************************************************************/
2415 uint8_t BuildRanFunctionRejectedList(uint8_t count, RanFunction *ranFunRejectedList, RANfunctionsIDcause_List_t *ranFuncRejectedList)
2417 uint8_t ranFuncIdx = 0;
2418 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
2420 ranFuncRejectedList->list.count = count;
2422 ranFuncRejectedList->list.size = ranFuncRejectedList->list.count*sizeof(RANfunctionIDcause_ItemIEs_t*);
2423 RIC_ALLOC(ranFuncRejectedList->list.array, ranFuncRejectedList->list.size);
2424 if(ranFuncRejectedList->list.array == NULLP)
2426 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array");
2430 for(ranFuncIdx = 0; ranFuncIdx< ranFuncRejectedList->list.count; ranFuncIdx++)
2432 RIC_ALLOC(ranFuncRejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t));
2433 if(ranFuncRejectedList->list.array[ranFuncIdx] == NULLP)
2435 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array item");
2438 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)ranFuncRejectedList->list.array[ranFuncIdx];
2439 ranFuncRejectedItemIe->id = ProtocolIE_IDE2_id_RANfunctionIEcause_Item;
2440 ranFuncRejectedItemIe->criticality= CriticalityE2_ignore;
2441 ranFuncRejectedItemIe->value.present = RANfunctionIDcause_ItemIEs__value_PR_RANfunctionIDcause_Item;
2442 ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID = ranFunRejectedList[ranFuncIdx].id;
2443 fillE2FailureCause(&ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.cause, CauseE2_PR_ricService,\
2444 CauseE2RICservice_ran_function_not_supported);
2450 /*******************************************************************
2452 * @brief build and send the ric service update Acknowledge
2456 * Function : BuildAndSendRicServiceUpdateAcknowledge
2458 * Functionality: build and send the ric service update Acknowledge
2459 * @return ROK - success
2460 * RFAILED - Acknowledge
2462 ******************************************************************/
2464 uint8_t BuildAndSendRicServiceUpdateAcknowledge(DuDb *duDb, int8_t transId, RicTmpRanFunList ricRanFuncList)
2466 E2AP_PDU_t *e2apMsg = NULL;
2467 asn_enc_rval_t encRetVal;
2468 uint8_t arrIdx=0, elementCnt=0, ret=RFAILED;;
2469 RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL;
2471 DU_LOG("\nINFO --> E2AP : Building Ric service update Acknowledge\n");
2474 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2475 if(e2apMsg == NULLP)
2477 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2480 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
2481 RIC_ALLOC(e2apMsg->choice.successfulOutcome , sizeof(struct SuccessfulOutcomeE2));
2482 if(e2apMsg->choice.successfulOutcome == NULLP)
2484 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2488 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
2489 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
2490 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge;
2491 ricServiceUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
2494 if(ricRanFuncList.numOfRanFunAccepted)
2496 if(ricRanFuncList.numOfRanFuneRejected)
2500 ricServiceUpdateAck->protocolIEs.list.count = elementCnt;
2501 ricServiceUpdateAck->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdateAcknowledge_IEs_t*);
2503 RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size);
2504 if(ricServiceUpdateAck->protocolIEs.list.array == NULLP)
2506 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
2510 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
2512 RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t));
2513 if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
2515 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
2519 if(arrIdx<elementCnt)
2521 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
2527 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2528 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2529 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_TransactionID;
2530 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
2532 if(ricRanFuncList.numOfRanFunAccepted)
2534 /* Accepted RAN function List */
2536 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
2537 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2538 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_RANfunctionsID_List;
2539 if(BuildRanFunctionAcceptedList(duDb, ricRanFuncList.numOfRanFunAccepted, ricRanFuncList.ranFunAcceptedList,\
2540 &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceUpdate)!=ROK)
2542 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
2547 if(ricRanFuncList.numOfRanFuneRejected)
2549 /* RAN Functions Rejected List */
2551 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsRejected;
2552 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2553 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_RANfunctionsIDcause_List;
2554 if(BuildRanFunctionRejectedList(ricRanFuncList.numOfRanFuneRejected, ricRanFuncList.ranFunRejectedList, \
2555 &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List)!=ROK)
2557 DU_LOG("\nERROR --> E2AP : Failed to build Ran function rejected list");
2563 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2564 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2566 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2568 /* Check encode results */
2569 if(encRetVal.encoded == ENCODE_FAIL)
2571 DU_LOG("\nERROR --> E2AP : Could not encode RIC service update Acknowledge structure (at %s)\n",\
2572 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2577 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Acknowledge\n");
2578 for(int i=0; i< encBufSize; i++)
2580 DU_LOG("%x",encBuf[i]);
2584 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
2586 DU_LOG("\nERROR --> E2AP : Sending RIC service update ack failed");
2592 FreeRicServiceUpdateAck(e2apMsg);
2596 /*******************************************************************
2598 * @brief process the RIC service update
2602 * Function : ProcRicserviceUpdate
2604 * Functionality: process the RIC service update
2606 * @return ROK - success
2609 ******************************************************************/
2611 void ProcRicServiceUpdate(uint32_t duId, RICserviceUpdate_t *ricServiceUpdate)
2613 RicTmpRanFunList ricRanFuncList;
2616 uint8_t duIdx = 0, elementCnt =0, arrIdx = 0;
2617 uint16_t ranFuncIdx = 0, failedRanFuncCount=0, recvdRanFuncCount=0;
2618 RANfunction_ItemIEs_t *ranFuncItemIe =NULL;
2619 RANfunction_Item_t *ranFuncItem =NULL;
2620 RANfunctionID_Item_t *ranFuncIdItem=NULL;
2621 RANfunctions_List_t *ranFuncList=NULL;
2622 RANfunctionsID_List_t *deleteList=NULL;
2623 RANfunctionID_ItemIEs_t *delRanFuncItem=NULL;
2625 SEARCH_DU_DB(duIdx, duId, duDb);
2628 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
2631 memset(&ricRanFuncList, 0, sizeof(RicTmpRanFunList));
2633 if(!ricServiceUpdate)
2635 DU_LOG("\nERROR --> E2AP : ricServiceUpdate pointer is null");
2639 if(!ricServiceUpdate->protocolIEs.list.array)
2641 DU_LOG("\nERROR --> E2AP : ricServiceUpdate array pointer is null");
2644 elementCnt = ricServiceUpdate->protocolIEs.list.count;
2645 for(arrIdx=0; arrIdx<ricServiceUpdate->protocolIEs.list.count; arrIdx++)
2647 if(!ricServiceUpdate->protocolIEs.list.array[arrIdx])
2649 DU_LOG("\nERROR --> E2AP : ricServiceUpdate array idx %d pointer is null",arrIdx);
2653 switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id)
2655 case ProtocolIE_IDE2_id_TransactionID:
2657 transId = ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
2659 if(transId < 0 || transId > 255)
2661 DU_LOG("\nERROR --> E2AP : Received invalid transId %d",transId);
2667 case ProtocolIE_IDE2_id_RANfunctionsAdded:
2669 ranFuncList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
2671 if(ranFuncList->list.array)
2673 for(ranFuncIdx=0;ranFuncIdx<ranFuncList->list.count; ranFuncIdx++)
2675 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx];
2676 ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
2678 /* Adding the ran function in temporary list */
2679 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].id = ranFuncItem->ranFunctionID;
2680 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].revisionCounter = ranFuncItem->ranFunctionRevision;
2681 ricRanFuncList.numOfRanFunAccepted++;
2683 /* Adding the new ran function in DB*/
2684 duDb->ranFunction[ranFuncItem->ranFunctionID-1].id = ranFuncItem->ranFunctionID;
2685 duDb->ranFunction[ranFuncItem->ranFunctionID-1].revisionCounter = ranFuncItem->ranFunctionRevision;
2686 duDb->numOfRanFunction++;
2688 /* Calculating total number of ran fuctions which are received for addition */
2689 recvdRanFuncCount++;
2695 case ProtocolIE_IDE2_id_RANfunctionsModified:
2698 ranFuncList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
2699 if(ranFuncList->list.array)
2701 for(ranFuncIdx = 0; ranFuncIdx< ranFuncList->list.count; ranFuncIdx++)
2703 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx];
2704 ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
2705 if(duDb->ranFunction[ranFuncItem->ranFunctionID-1].id != ranFuncItem->ranFunctionID)
2707 /* Calculating total number of ran fuctions which are not present */
2708 failedRanFuncCount++;
2710 /* Adding the ran function in temporary list */
2711 ricRanFuncList.ranFunRejectedList[ricRanFuncList.numOfRanFuneRejected].id = ranFuncItem->ranFunctionID;
2712 ricRanFuncList.numOfRanFuneRejected++;
2717 /* Adding the ran function in temporary list */
2718 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].id = ranFuncItem->ranFunctionID;
2719 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].revisionCounter = ranFuncItem->ranFunctionRevision;
2720 ricRanFuncList.numOfRanFunAccepted++;
2722 /* Updating the new ran function in DB*/
2723 duDb->ranFunction[ranFuncItem->ranFunctionID-1].revisionCounter = ranFuncItem->ranFunctionRevision;
2725 /* Calculating total number of ran fuctions which are received for modification */
2726 recvdRanFuncCount++;
2731 case ProtocolIE_IDE2_id_RANfunctionsDeleted:
2734 deleteList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
2735 if(deleteList->list.array)
2737 for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++)
2739 delRanFuncItem = (RANfunctionID_ItemIEs_t*) deleteList->list.array[ranFuncIdx];
2740 ranFuncIdItem = &delRanFuncItem->value.choice.RANfunctionID_Item;
2741 if(duDb->ranFunction[ranFuncIdItem->ranFunctionID-1].id == ranFuncIdItem->ranFunctionID)
2743 memset(&duDb->ranFunction[ranFuncIdItem->ranFunctionID-1], 0, sizeof(RanFunction));
2744 duDb->numOfRanFunction--;
2747 /* Calculating total number of ran fuctions which are received for deletion */
2748 recvdRanFuncCount++;
2756 DU_LOG("\nERROR --> E2AP : IE [%ld] is not supported",ricServiceUpdate->protocolIEs.list.array[arrIdx]->id);
2762 /* Sending RIC Service Update Failed if all RAN Functions received fail or if any IE processing fails
2763 * Else sending RIC Service Update Acknowledge */
2764 if((elementCnt > arrIdx) ||((recvdRanFuncCount > 0) && (recvdRanFuncCount == failedRanFuncCount)))
2766 if(BuildAndSendRicServiceUpdateFailure(duDb->duId, transId, CauseE2_PR_misc, CauseE2Misc_unspecified) != ROK)
2768 DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update Failure");
2774 if(BuildAndSendRicServiceUpdateAcknowledge(duDb, transId, ricRanFuncList) != ROK)
2776 DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update acknowledge");
2783 /*******************************************************************
2785 * @brief Handles received E2AP message and sends back response
2789 * Function : E2APMsgHdlr
2792 * - Decodes received E2AP control message
2793 * - Prepares response message, encodes and sends to SCTP
2796 * @return ROK - success
2799 * ****************************************************************/
2800 void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf)
2806 E2AP_PDU_t *e2apMsg;
2807 asn_dec_rval_t rval; /* Decoder return value */
2808 E2AP_PDU_t e2apasnmsg ;
2810 DU_LOG("\nINFO --> E2AP : Received E2AP message buffer");
2811 ODU_PRINT_MSG(mBuf, 0,0);
2813 /* Copy mBuf into char array to decode it */
2814 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
2815 RIC_ALLOC(recvBuf, (Size)recvBufLen);
2817 if(recvBuf == NULLP)
2819 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
2822 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
2824 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
2828 DU_LOG("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
2829 for(i=0; i< recvBufLen; i++)
2831 DU_LOG("%x",recvBuf[i]);
2834 /* Decoding flat buffer into E2AP messsage */
2835 e2apMsg = &e2apasnmsg;
2836 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
2838 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
2839 RIC_FREE(recvBuf, (Size)recvBufLen);
2841 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2843 DU_LOG("\nERROR --> E2AP : ASN decode failed");
2847 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2849 switch(e2apMsg->present)
2851 case E2AP_PDU_PR_initiatingMessage:
2853 switch(e2apMsg->choice.initiatingMessage->value.present)
2855 case InitiatingMessageE2__value_PR_E2setupRequest:
2857 DU_LOG("\nINFO --> E2AP : E2 setup request received");
2858 ProcE2SetupReq(duId, &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest);
2861 case InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate:
2863 DU_LOG("\nINFO --> E2AP : E2 node config update received");
2864 BuildAndSendE2NodeConfigUpdateAck(*duId);
2867 case InitiatingMessageE2__value_PR_ResetRequestE2:
2869 DU_LOG("\nINFO --> E2AP : E2 Reset Request received");
2870 ProcE2ResetReq(*duId, &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2);
2873 case InitiatingMessageE2__value_PR_RICindication:
2875 DU_LOG("\nINFO --> E2AP : RIC Indication Acknowledged");
2878 case InitiatingMessageE2__value_PR_RICserviceUpdate:
2880 DU_LOG("\nINFO --> E2AP : RIC Service update received");
2881 ProcRicServiceUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate);
2887 DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]",e2apMsg->choice.initiatingMessage->value.present);
2890 }/* End of switch(initiatingMessage) */
2893 case E2AP_PDU_PR_successfulOutcome:
2895 switch(e2apMsg->choice.successfulOutcome->value.present)
2897 case SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse:
2899 ProcRicSubscriptionResponse(*duId);
2904 DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]",e2apMsg->choice.successfulOutcome->value.present);
2913 DU_LOG("\nERROR --> E2AP : Invalid type message type ");
2917 }/* End of switch(e2apMsg->present) */
2918 } /* End of E2APMsgHdlr */
2921 /**********************************************************************
2923 **********************************************************************/