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[ricActionId-1].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[ricActionId-1], 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;
1113 asn_enc_rval_t encRetVal; /* Encoder return value */
1114 RanFunction *ranFuncDb = &duDb->ranFunction[0];
1116 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Request\n");
1120 RIC_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
1121 if(e2apRicMsg == NULLP)
1123 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1127 e2apRicMsg->present = E2AP_PDU_PR_initiatingMessage;
1128 RIC_ALLOC(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1129 if(e2apRicMsg->choice.initiatingMessage == NULLP)
1131 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1134 e2apRicMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscription;
1135 e2apRicMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
1136 e2apRicMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionRequest;
1138 ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
1141 ricSubscriptionReq->protocolIEs.list.count = elementCnt;
1142 ricSubscriptionReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionRequest_IEs_t);
1144 /* Initialize the subscription members */
1145 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array, ricSubscriptionReq->protocolIEs.list.size);
1146 if(ricSubscriptionReq->protocolIEs.list.array == NULLP)
1148 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1152 for(idx=0; idx<elementCnt; idx++)
1154 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array[idx], sizeof(RICsubscriptionRequest_IEs_t));
1155 if(ricSubscriptionReq->protocolIEs.list.array[idx] == NULLP)
1157 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1161 if(idx < elementCnt)
1164 /* Filling RIC Request Id */
1166 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
1167 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1168 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
1169 RICsubscriptionRequest_IEs__value_PR_RICrequestID;
1170 if(BuildNewRicRequestId(&ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICrequestID, \
1171 &ranFuncDb->subscriptionList[ranFuncDb->numOfSubscription].requestId) != ROK)
1173 DU_LOG("\nERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__);
1178 /* Filling RAN Function Id */
1180 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
1181 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1182 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
1183 RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
1184 ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID = ranFuncDb->id;
1186 /* Filling RIC Subscription Details */
1188 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICsubscriptionDetails;
1189 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1190 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
1191 RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails;
1192 if(BuildRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails),\
1193 &ranFuncDb->subscriptionList[ranFuncDb->numOfSubscription]) != ROK)
1195 DU_LOG("\nERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__);
1199 /* Prints the Msg formed */
1200 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
1202 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1204 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf);
1205 if(encRetVal.encoded == ENCODE_FAIL)
1207 DU_LOG("\nERROR --> E2AP : Could not encode RicSubscriptionRequest structure (at %s)\n",\
1208 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1213 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionRequest\n");
1214 for(int i=0; i< encBufSize; i++)
1216 DU_LOG("%x",encBuf[i]);
1221 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
1223 DU_LOG("\nERROR --> E2AP : Sending RIC subscription Request failed");
1227 ranFuncDb->numOfSubscription++;
1233 memset(&ranFuncDb->subscriptionList[ranFuncDb->numOfSubscription], 0, sizeof(RicSubscription));
1234 FreeRicSubscriptionReq(e2apRicMsg);
1238 /*******************************************************************
1240 * @brief Process RicSubscriptionResponse
1244 * Function : ProcRicSubscriptionRsp
1246 * Functionality: Processes RicSubscriptionRsp
1248 * @return ROK - void
1250 ******************************************************************/
1252 void ProcRicSubscriptionResponse(uint32_t duId, RICsubscriptionResponse_t *ricSubscriptionRsp)
1254 uint8_t duIdx = 0, ieIdx = 0,subsIdx = 0, notAdmitIdx = 0;
1255 uint8_t ranFuncId = 0, actionId = 0;
1257 bool ricReqIdDecoded = false;
1258 RicRequestId ricReqId;
1259 RanFunction *ranFuncDb = NULLP;
1260 RICsubscriptionResponse_IEs_t *ricSubsRspIe = NULLP;
1261 RICaction_NotAdmitted_List_t *notAdmitList = NULLP;
1263 DU_LOG("\nINFO --> E2AP : RIC Subscription Response received");
1266 SEARCH_DU_DB(duIdx, duId, duDb);
1269 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
1273 memset(&ricReqId, 0, sizeof(RicRequestId));
1274 if(ricSubscriptionRsp)
1276 if(ricSubscriptionRsp->protocolIEs.list.array)
1278 for(ieIdx=0; ieIdx<ricSubscriptionRsp->protocolIEs.list.count; ieIdx++)
1280 if(ricSubscriptionRsp->protocolIEs.list.array[ieIdx])
1282 ricSubsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
1283 switch(ricSubscriptionRsp->protocolIEs.list.array[ieIdx]->id)
1285 case ProtocolIE_IDE2_id_RICrequestID:
1287 ricReqId.requestorId = ricSubsRspIe->value.choice.RICrequestID.ricRequestorID;
1288 ricReqId.instanceId = ricSubsRspIe->value.choice.RICrequestID.ricInstanceID;
1289 ricReqIdDecoded = true;
1292 case ProtocolIE_IDE2_id_RANfunctionID:
1294 ranFuncId = ricSubsRspIe->value.choice.RANfunctionID;
1295 if(duDb->ranFunction[ranFuncId-1].id == ranFuncId)
1297 ranFuncDb = &duDb->ranFunction[ranFuncId-1];
1301 DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionResponse: RAN Function ID [%d] not found", ranFuncId);
1306 case ProtocolIE_IDE2_id_RICactions_Admitted:
1310 case ProtocolIE_IDE2_id_RICactions_NotAdmitted:
1312 if(!(ranFuncDb && ricReqIdDecoded))
1315 notAdmitList = &ricSubsRspIe->value.choice.RICaction_NotAdmitted_List;
1316 for(notAdmitIdx = 0; notAdmitIdx < notAdmitList->list.count; notAdmitIdx++)
1318 actionId = ((RICaction_NotAdmitted_ItemIEs_t *)(notAdmitList->list.array[notAdmitIdx]))->\
1319 value.choice.RICaction_NotAdmitted_Item.ricActionID;
1321 /* Remove action from RAN Function's subscription list */
1322 for(subsIdx = 0; subsIdx < ranFuncDb->numOfSubscription; subsIdx++)
1324 if((ranFuncDb->subscriptionList[subsIdx].requestId.requestorId == ricReqId.requestorId) &&
1325 (ranFuncDb->subscriptionList[subsIdx].requestId.instanceId == ricReqId.instanceId))
1327 if(ranFuncDb->subscriptionList[subsIdx].actionSequence[actionId-1].id == actionId)
1329 memset(&ranFuncDb->subscriptionList[subsIdx].actionSequence[actionId-1], 0, \
1330 sizeof(ActionInfo));
1331 ranFuncDb->subscriptionList[subsIdx].numOfActions--;
1346 /*******************************************************************
1348 * @brief deallocate the memory allocated in E2SetupFailure
1352 * Function : FreeE2SetupFailure
1354 * Functionality: deallocate the memory allocated in E2SetupFailure
1356 * @params[in] E2AP_PDU_t *e2apMsg
1359 * ****************************************************************/
1360 void FreeE2SetupFailure(E2AP_PDU_t *e2apMsg)
1363 E2setupFailure_t *e2SetupFail;
1367 if(e2apMsg->choice.unsuccessfulOutcome)
1369 e2SetupFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
1370 if(e2SetupFail->protocolIEs.list.array)
1372 for(arrIdx=0; arrIdx<e2SetupFail->protocolIEs.list.count; arrIdx++)
1374 RIC_FREE(e2SetupFail->protocolIEs.list.array[arrIdx], sizeof(E2setupFailureIEs_t));
1376 RIC_FREE(e2SetupFail->protocolIEs.list.array, e2SetupFail->protocolIEs.list.size);
1378 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
1380 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1384 /*******************************************************************
1386 * @brief Buld and send the E2 Setup failure
1390 * Function : BuildAndSendE2SetupFailure
1393 * - Buld and send the E2 Setup failure
1394 * @return ROK - success
1397 * ****************************************************************/
1399 uint8_t BuildAndSendE2SetupFailure(uint32_t duId, uint8_t transId)
1401 E2AP_PDU_t *e2apMsg = NULL;
1402 E2setupFailure_t *e2SetupFailure;
1403 asn_enc_rval_t encRetVal;
1406 bool memAllocFailed = false;
1408 DU_LOG("\nINFO --> E2AP : Building E2 Setup failure\n");
1411 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1412 if(e2apMsg == NULLP)
1414 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1417 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
1418 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
1419 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
1421 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1425 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
1426 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
1427 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2setupFailure;
1428 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
1431 e2SetupFailure->protocolIEs.list.count = elementCnt;
1432 e2SetupFailure->protocolIEs.list.size = elementCnt * sizeof(struct E2setupFailureIEs *);
1434 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array, e2SetupFailure->protocolIEs.list.size);
1435 if(e2SetupFailure->protocolIEs.list.array == NULLP)
1437 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
1441 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
1443 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array[arrIdx], sizeof(struct E2setupFailureIEs));
1444 if(e2SetupFailure->protocolIEs.list.array[arrIdx] == NULLP)
1446 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
1447 memAllocFailed = true;
1452 if(memAllocFailed == true)
1454 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
1460 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1461 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1462 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID;
1463 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
1466 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
1467 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1468 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2;
1469 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = CauseE2_PR_protocol;
1470 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.protocol = CauseE2Protocol_unspecified;
1473 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
1474 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
1475 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2;
1476 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
1478 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1479 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1481 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
1483 /* Check encode results */
1484 if(encRetVal.encoded == ENCODE_FAIL)
1486 DU_LOG("\nERROR --> E2AP : Could not encode E2 Setup failure structure (at %s)\n",\
1487 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1492 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Setup Failure\n");
1493 for(int i=0; i< encBufSize; i++)
1495 DU_LOG("%x",encBuf[i]);
1499 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
1501 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Failure failed");
1507 FreeE2SetupFailure(e2apMsg);
1510 /*******************************************************************
1512 * @brief process the e2setup request
1516 * Function : ProcE2SetupReq
1518 * Functionality: process the e2setup request
1520 * @return ROK - success
1523 ******************************************************************/
1525 uint8_t ProcE2SetupReq(uint32_t *duId, E2setupRequest_t *e2SetupReq)
1527 uint8_t arrIdx = 0, e2NodeAddListIdx =0, duIdx = 0, transId =0, ranFuncIdx;
1529 E2nodeComponentConfigAddition_List_t *e2NodeAddList;
1530 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem;
1531 RANfunction_ItemIEs_t *ranFuncItemIe;
1532 RANfunction_Item_t *ranFunItem;
1533 RANfunctions_List_t *ranFunctionsList;
1537 if(e2SetupReq->protocolIEs.list.array)
1539 for(arrIdx=0; arrIdx<e2SetupReq->protocolIEs.list.count; arrIdx++)
1541 if(e2SetupReq->protocolIEs.list.array[arrIdx])
1543 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
1545 case ProtocolIE_IDE2_id_TransactionID:
1547 transId = e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
1550 case ProtocolIE_IDE2_id_GlobalE2node_ID:
1552 if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID)
1554 *duId =e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID->buf[0];
1556 SEARCH_DU_DB(duIdx, *duId, duDb);
1559 duDb = &ricCb.duInfo[ricCb.numDu];
1562 memset(duDb, 0, sizeof(DuDb));
1567 case ProtocolIE_IDE2_id_RANfunctionsAdded:
1569 ranFunctionsList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
1571 if(ranFunctionsList->list.array)
1573 for(ranFuncIdx=0;ranFuncIdx<ranFunctionsList->list.count; ranFuncIdx++)
1575 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
1576 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
1577 duDb->ranFunction[ranFunItem->ranFunctionID-1].id = ranFunItem->ranFunctionID;
1578 duDb->ranFunction[ranFunItem->ranFunctionID-1].revisionCounter = ranFunItem->ranFunctionRevision;
1579 duDb->numOfRanFunction++;
1584 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
1586 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
1587 if(e2NodeAddList->list.array)
1589 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
1591 if(e2NodeAddList->list.array[e2NodeAddListIdx])
1594 (E2nodeComponentConfigAddition_ItemIEs_t *)e2NodeAddList->list.array[e2NodeAddListIdx];
1595 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.\
1596 choice.e2nodeComponentInterfaceTypeF1)
1598 duDb->e2NodeComponent.interfaceType = F1;
1599 duDb->e2NodeComponent.componentId = \
1600 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.\
1601 choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0];
1616 if(BuildAndSendE2SetupRsp(duDb, transId) !=ROK)
1618 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 setup response");
1624 /*******************************************************************
1626 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
1630 * Function : FreeE2NodeConfigUpdate
1633 * - freeing the memory allocated for E2nodeConfigurationUpdate
1635 * @params[in] E2AP_PDU_t *e2apMsg
1636 * @return ROK - success
1639 * ****************************************************************/
1640 void FreeE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg)
1643 E2nodeConfigurationUpdate_t *e2NodeConfigUpdateAck;
1645 if(e2apMsg != NULLP)
1647 if(e2apMsg->choice.successfulOutcome != NULLP)
1649 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
1650 if(e2NodeConfigUpdateAck->protocolIEs.list.array != NULLP)
1652 for(arrIdx = 0; arrIdx < e2NodeConfigUpdateAck->protocolIEs.list.count; arrIdx++)
1654 RIC_FREE(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_t));
1656 RIC_FREE(e2NodeConfigUpdateAck->protocolIEs.list.array, e2NodeConfigUpdateAck->protocolIEs.list.size);
1658 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1660 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1664 /*******************************************************************
1666 * @brief Buld and send the E2 node config update msg
1670 * Function : BuildAndSendE2NodeConfigUpdate
1673 * - Buld and send the E2 node config update msg
1674 * @return ROK - success
1677 * ****************************************************************/
1679 uint8_t BuildAndSendE2NodeConfigUpdateAck(uint32_t duId)
1681 uint8_t arrIdx = 0,elementCnt = 1;
1683 E2AP_PDU_t *e2apMsg = NULLP;
1684 E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck = NULLP;
1685 asn_enc_rval_t encRetVal; /* Encoder return value */
1687 DU_LOG("\nINFO --> E2AP : Building E2 Node config update Ack Message\n");
1690 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1691 if(e2apMsg == NULLP)
1693 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1696 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
1697 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1698 if(e2apMsg->choice.successfulOutcome == NULLP)
1700 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1701 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1705 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
1706 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
1707 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge;
1708 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
1710 e2NodeConfigUpdateAck->protocolIEs.list.count = elementCnt;
1711 e2NodeConfigUpdateAck->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t*);
1712 /* Initialize the Ric Indication members */
1713 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array, \
1714 e2NodeConfigUpdateAck->protocolIEs.list.size);
1715 if(e2NodeConfigUpdateAck->protocolIEs.list.array == NULLP)
1717 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdateAck failed");
1721 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
1723 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t));
1724 if(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
1727 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdateAck failed");
1734 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1735 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1736 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_TransactionID;
1737 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = TRANS_ID;
1740 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1742 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1744 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1746 if(encRetVal.encoded == ENCODE_FAIL)
1748 DU_LOG("\nERROR --> E2AP : Could not encode E2 Node config update ack structure (at %s)\n",\
1749 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1754 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node config update ack \n");
1755 for(int i=0; i< encBufSize; i++)
1757 DU_LOG("%x",encBuf[i]);
1763 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
1765 DU_LOG("\nERROR --> E2AP : Failed to send E2 Node config update ack ");
1772 FreeE2NodeConfigUpdateAck(e2apMsg);
1776 /*******************************************************************
1778 * @brief Deallocate the memory allocated for E2 Reset Response
1782 * Function : FreeE2ResetResponse
1785 * - freeing the memory allocated for E2ResetResponse
1787 * @params[in] E2AP_PDU_t *e2apMsg
1788 * @return ROK - success
1791 * ****************************************************************/
1792 void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
1795 ResetResponseE2_t *resetResponse;
1797 if(e2apMsg != NULLP)
1799 if(e2apMsg->choice.successfulOutcome != NULLP)
1801 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
1802 if(resetResponse->protocolIEs.list.array)
1804 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
1806 if(resetResponse->protocolIEs.list.array[ieIdx])
1808 RIC_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
1811 RIC_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
1813 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1815 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1819 /*******************************************************************
1821 * @brief Buld and send the E2 Reset Response msg
1825 * Function : BuildAndSendE2ResetResponse
1828 * - Buld and send the E2 Reset Response Message
1829 * @return ROK - success
1832 * ****************************************************************/
1833 uint8_t BuildAndSendResetResponse(uint32_t duId, uint8_t transId)
1835 uint8_t ieIdx = 0, elementCnt = 0;
1836 uint8_t ret = RFAILED;
1837 E2AP_PDU_t *e2apMsg = NULLP;
1838 ResetResponseE2_t *resetResponse;
1839 asn_enc_rval_t encRetVal; /* Encoder return value */
1841 DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
1844 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1845 if(e2apMsg == NULLP)
1847 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
1850 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
1852 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1853 if(e2apMsg->choice.successfulOutcome == NULLP)
1855 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
1856 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1860 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset;
1861 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
1862 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2;
1863 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
1866 resetResponse->protocolIEs.list.count = elementCnt;
1867 resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *);
1868 RIC_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
1869 if(!resetResponse->protocolIEs.list.array)
1871 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
1875 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
1877 RIC_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
1878 if(!resetResponse->protocolIEs.list.array[ieIdx])
1880 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
1884 if(ieIdx < elementCnt)
1888 resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1889 resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
1890 resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID;
1891 resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
1893 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1895 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1897 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
1898 if(encRetVal.encoded == ENCODE_FAIL)
1900 DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
1901 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1906 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
1907 for(int i=0; i< encBufSize; i++)
1909 DU_LOG("%x",encBuf[i]);
1914 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
1916 DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
1924 FreeE2ResetResponse(e2apMsg);
1928 /*******************************************************************
1930 * @brief process the E2 Reset Request
1934 * Function : ProcE2ResetReq
1936 * Functionality: Process E2 Reset Request
1938 * @return ROK - success
1941 ******************************************************************/
1943 uint8_t ProcE2ResetReq(uint32_t duId, ResetRequestE2_t *resetReq)
1945 uint8_t ieIdx = 0, duIdx = 0;
1946 uint8_t transId = 0, cause = 0;
1951 if(resetReq->protocolIEs.list.array)
1953 for(ieIdx=0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
1955 if(resetReq->protocolIEs.list.array[ieIdx])
1957 switch(resetReq->protocolIEs.list.array[ieIdx]->id)
1959 case ProtocolIE_IDE2_id_TransactionID:
1960 transId = resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
1962 case ProtocolIE_IDE2_id_CauseE2:
1963 DU_LOG("\nDEBUG --> E2AP : Reset reason %d", resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present);
1964 switch(resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present)
1966 case CauseE2_PR_NOTHING:
1968 case CauseE2_PR_ricRequest:
1969 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricRequest;
1971 case CauseE2_PR_ricService:
1972 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricService;
1974 case CauseE2_PR_e2Node:
1975 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.e2Node;
1977 case CauseE2_PR_transport:
1978 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.transport;
1980 case CauseE2_PR_protocol:
1981 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.protocol;
1983 case CauseE2_PR_misc:
1984 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.misc;
1987 DU_LOG("\nDEBUG --> E2AP : Reset cause %d", cause);
1994 BuildAndSendResetResponse(duId, transId);
1998 /*******************************************************************
2000 * @brief deallocate the memory allocated in building the
2001 * Service Query message
2005 * Function : FreeRicServiceQuery
2007 * Functionality: deallocate the memory allocated in building
2008 * Ric Service Query message
2010 * @params[in] E2AP_PDU_t *e2apMsg
2013 * ****************************************************************/
2015 void FreeRicServiceQuery(E2AP_PDU_t *e2apMsg)
2017 uint8_t arrIdx = 0, ranFuncIdx=0;
2018 RANfunctionsID_List_t *ranFuncAcceptedList=NULL;
2019 RICserviceQuery_t *ricServiceQuery=NULL;
2023 if(e2apMsg->choice.initiatingMessage)
2025 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
2026 if(ricServiceQuery->protocolIEs.list.array)
2028 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
2030 if(ricServiceQuery->protocolIEs.list.array[arrIdx])
2032 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
2034 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
2036 ranFuncAcceptedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
2037 if(ranFuncAcceptedList->list.array)
2039 for(ranFuncIdx=0;ranFuncIdx<ranFuncAcceptedList->list.count; ranFuncIdx++)
2041 RIC_FREE(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
2043 RIC_FREE(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
2047 case RICserviceQuery_IEs__value_PR_TransactionID:
2052 RIC_FREE(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
2055 RIC_FREE(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
2057 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2059 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2063 /*******************************************************************
2065 * @brief build and send the ric service Query
2069 * Function : BuildAndSendRicServiceQuery
2071 * Functionality: build and send the ric service Query
2072 * @return ROK - success
2073 * RFAILED - Acknowledge
2075 ******************************************************************/
2077 uint8_t BuildAndSendRicServiceQuery(DuDb *duDb)
2081 uint8_t ret = RFAILED;
2082 bool memAllocFailed = false;
2083 E2AP_PDU_t *e2apMsg = NULL;
2084 asn_enc_rval_t encRetVal;
2085 RICserviceQuery_t *ricServiceQuery;
2087 DU_LOG("\nINFO --> E2AP : Building Ric service Query\n");
2090 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2091 if(e2apMsg == NULLP)
2093 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2096 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
2097 RIC_ALLOC(e2apMsg->choice.initiatingMessage , sizeof(struct InitiatingMessageE2));
2098 if(e2apMsg->choice.initiatingMessage == NULLP)
2100 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2104 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceQuery;
2105 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
2106 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceQuery;
2107 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
2110 /* Fill Accepted RAN function IE If Ran function information is stored in databse */
2111 if(duDb->numOfRanFunction)
2114 ricServiceQuery->protocolIEs.list.count = elementCnt;
2115 ricServiceQuery->protocolIEs.list.size = elementCnt * sizeof(RICserviceQuery_IEs_t*);
2117 RIC_ALLOC(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
2118 if(ricServiceQuery->protocolIEs.list.array == NULLP)
2120 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
2124 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
2126 RIC_ALLOC(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
2127 if(ricServiceQuery->protocolIEs.list.array[arrIdx] == NULLP)
2129 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
2130 memAllocFailed = true;
2134 if(memAllocFailed == true)
2136 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
2142 ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2143 ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2144 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_TransactionID;
2145 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = assignTransactionId(duDb);
2147 if(duDb->numOfRanFunction)
2149 /* Accepted RAN function Id */
2151 ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
2152 ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2153 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_RANfunctionsID_List;
2154 if(BuildRanFunctionAcceptedList(duDb, 0, NULL, &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceQuery)!=ROK)
2156 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
2161 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2162 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2164 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2166 /* Check encode results */
2167 if(encRetVal.encoded == ENCODE_FAIL)
2169 DU_LOG("\nERROR --> E2AP : Could not encode RIC service Query structure (at %s)\n",\
2170 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2175 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service Query\n");
2176 for(int i=0; i< encBufSize; i++)
2178 DU_LOG("%x",encBuf[i]);
2182 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
2184 DU_LOG("\nERROR --> E2AP : Sending of RIC service Query failed");
2191 FreeRicServiceQuery(e2apMsg);
2195 /*******************************************************************
2197 * @brief deallocate the memory allocated in RicServiceUpdateFailure
2201 * Function : FreeRicServiceUpdateFailure
2203 * Functionality: deallocate the memory allocated in RicServiceUpdatefailure
2205 * @params[in] E2AP_PDU_t *e2apMsg
2208 * ****************************************************************/
2210 void FreeRicServiceUpdateFailure(E2AP_PDU_t *e2apMsg)
2213 RICserviceUpdateFailure_t *ricServiceUpdateFailure=NULL;
2217 if(e2apMsg->choice.unsuccessfulOutcome)
2219 ricServiceUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
2220 if(ricServiceUpdateFailure->protocolIEs.list.array)
2222 for(arrIdx=0; arrIdx<ricServiceUpdateFailure->protocolIEs.list.count; arrIdx++)
2224 RIC_FREE(ricServiceUpdateFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t));
2226 RIC_FREE(ricServiceUpdateFailure->protocolIEs.list.array, ricServiceUpdateFailure->protocolIEs.list.size);
2228 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
2230 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2234 /*******************************************************************
2236 * @brief fill E2 failure cause
2240 * Function : fillE2FailureCause
2242 * Functionality: fill E2 failure cause
2243 * @return ROK - success
2246 ******************************************************************/
2248 void fillE2FailureCause(CauseE2_t *cause, CauseE2_PR causePresent, uint8_t reason)
2250 cause->present = causePresent;
2252 switch(cause->present)
2254 case CauseE2_PR_ricRequest:
2255 cause->choice.ricRequest = reason;
2257 case CauseE2_PR_ricService:
2258 cause->choice.ricService = reason;
2260 case CauseE2_PR_e2Node:
2261 cause->choice.e2Node = reason;
2263 case CauseE2_PR_transport:
2264 cause->choice.transport = reason;
2266 case CauseE2_PR_protocol:
2267 cause->choice.protocol = reason;
2269 case CauseE2_PR_misc:
2270 cause->choice.misc = reason;
2273 cause->choice.misc = CauseE2Misc_unspecified;
2278 /*******************************************************************
2280 * @brief build and send the ric service update failure
2284 * Function : BuildAndSendRicServiceUpdateFailure
2286 * Functionality: build and send the ric service update failure
2287 * @return ROK - success
2290 ******************************************************************/
2292 uint8_t BuildAndSendRicServiceUpdateFailure(uint32_t duId, int8_t transId, CauseE2_PR causePresent, uint8_t reason)
2295 E2AP_PDU_t *e2apMsg = NULL;
2296 asn_enc_rval_t encRetVal;
2297 uint8_t ret = RFAILED;
2299 uint8_t elementCnt=0;
2300 RICserviceUpdateFailure_t *ricServiceFailure=NULL;
2302 DU_LOG("\nINFO --> E2AP : Building Ric service update failure\n");
2305 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2306 if(e2apMsg == NULLP)
2308 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2311 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
2312 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
2313 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
2315 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2319 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
2320 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
2321 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure;
2322 ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
2325 ricServiceFailure->protocolIEs.list.count = elementCnt;
2326 ricServiceFailure->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdateFailure_IEs_t *);
2328 RIC_ALLOC(ricServiceFailure->protocolIEs.list.array, ricServiceFailure->protocolIEs.list.size);
2329 if(ricServiceFailure->protocolIEs.list.array == NULLP)
2331 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
2335 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
2337 RIC_ALLOC(ricServiceFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t));
2338 if(ricServiceFailure->protocolIEs.list.array[arrIdx] == NULLP)
2340 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
2344 if(arrIdx<elementCnt)
2346 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
2352 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2353 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2354 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_TransactionID;
2355 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
2358 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
2359 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2360 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_CauseE2;
2361 fillE2FailureCause(&ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, causePresent, reason);
2364 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
2365 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
2366 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_TimeToWaitE2;
2367 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
2369 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2370 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2372 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2374 /* Check encode results */
2375 if(encRetVal.encoded == ENCODE_FAIL)
2377 DU_LOG("\nERROR --> E2AP : Could not encode RIC service update failure structure (at %s)\n",\
2378 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2383 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Failure\n");
2384 for(int i=0; i< encBufSize; i++)
2386 DU_LOG("%x",encBuf[i]);
2390 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
2392 DU_LOG("\nERROR --> E2AP : Sending RIC service update failed");
2399 FreeRicServiceUpdateFailure(e2apMsg);
2404 /*******************************************************************
2406 * @brief deallocate the memory allocated in RicServiceUpdateAck(
2410 * Function : FreeRicServiceUpdateAck
2412 * Functionality: deallocate the memory allocated in RicServiceUpdateAck
2414 * @params[in] E2AP_PDU_t *e2apMsg
2417 * ****************************************************************/
2419 void FreeRicServiceUpdateAck(E2AP_PDU_t *e2apMsg)
2421 uint8_t arrIdx = 0, ranFuncIdx=0;
2422 RANfunctionsID_List_t *acceptedList=NULL;
2423 RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL;
2424 RANfunctionsIDcause_List_t *rejectedList=NULL;
2428 if(e2apMsg->choice.successfulOutcome)
2430 ricServiceUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
2431 if(ricServiceUpdateAck->protocolIEs.list.array)
2433 for(arrIdx=0; arrIdx<ricServiceUpdateAck->protocolIEs.list.count; arrIdx++)
2435 if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx])
2437 switch(ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id)
2439 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
2441 acceptedList= &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
2442 if(acceptedList->list.array)
2444 for(ranFuncIdx=0;ranFuncIdx<acceptedList->list.count; ranFuncIdx++)
2446 RIC_FREE(acceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
2448 RIC_FREE(acceptedList->list.array, acceptedList->list.size);
2453 case ProtocolIE_IDE2_id_RANfunctionsRejected:
2455 rejectedList= &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
2456 if(rejectedList->list.array)
2458 for(ranFuncIdx=0;ranFuncIdx<rejectedList->list.count; ranFuncIdx++)
2460 RIC_FREE(rejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t));
2462 RIC_FREE(rejectedList->list.array, rejectedList->list.size);
2467 RIC_FREE(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t));
2470 RIC_FREE(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size);
2472 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2474 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2478 /*******************************************************************
2480 * @brief Build RAN function rejected list
2484 * Function : BuildRanFunctionRejectedList
2486 * Functionality: Build RAN function rejected list
2489 * Count of ran functions to be rejected in the list
2490 * Received list of RAN functions
2492 * @return ROK - success
2494 * ****************************************************************/
2496 uint8_t BuildRanFunctionRejectedList(uint8_t count, RanFunction *ranFunRejectedList, RANfunctionsIDcause_List_t *ranFuncRejectedList)
2498 uint8_t ranFuncIdx = 0;
2499 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
2501 ranFuncRejectedList->list.count = count;
2503 ranFuncRejectedList->list.size = ranFuncRejectedList->list.count*sizeof(RANfunctionIDcause_ItemIEs_t*);
2504 RIC_ALLOC(ranFuncRejectedList->list.array, ranFuncRejectedList->list.size);
2505 if(ranFuncRejectedList->list.array == NULLP)
2507 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array");
2511 for(ranFuncIdx = 0; ranFuncIdx< ranFuncRejectedList->list.count; ranFuncIdx++)
2513 RIC_ALLOC(ranFuncRejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t));
2514 if(ranFuncRejectedList->list.array[ranFuncIdx] == NULLP)
2516 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array item");
2519 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)ranFuncRejectedList->list.array[ranFuncIdx];
2520 ranFuncRejectedItemIe->id = ProtocolIE_IDE2_id_RANfunctionIEcause_Item;
2521 ranFuncRejectedItemIe->criticality= CriticalityE2_ignore;
2522 ranFuncRejectedItemIe->value.present = RANfunctionIDcause_ItemIEs__value_PR_RANfunctionIDcause_Item;
2523 ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID = ranFunRejectedList[ranFuncIdx].id;
2524 fillE2FailureCause(&ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.cause, CauseE2_PR_ricService,\
2525 CauseE2RICservice_ran_function_not_supported);
2531 /*******************************************************************
2533 * @brief build and send the ric service update Acknowledge
2537 * Function : BuildAndSendRicServiceUpdateAcknowledge
2539 * Functionality: build and send the ric service update Acknowledge
2540 * @return ROK - success
2541 * RFAILED - Acknowledge
2543 ******************************************************************/
2545 uint8_t BuildAndSendRicServiceUpdateAcknowledge(DuDb *duDb, int8_t transId, RicTmpRanFunList ricRanFuncList)
2547 E2AP_PDU_t *e2apMsg = NULL;
2548 asn_enc_rval_t encRetVal;
2549 uint8_t arrIdx=0, elementCnt=0, ret=RFAILED;;
2550 RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL;
2552 DU_LOG("\nINFO --> E2AP : Building Ric service update Acknowledge\n");
2555 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2556 if(e2apMsg == NULLP)
2558 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2561 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
2562 RIC_ALLOC(e2apMsg->choice.successfulOutcome , sizeof(struct SuccessfulOutcomeE2));
2563 if(e2apMsg->choice.successfulOutcome == NULLP)
2565 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2569 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
2570 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
2571 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge;
2572 ricServiceUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
2575 if(ricRanFuncList.numOfRanFunAccepted)
2577 if(ricRanFuncList.numOfRanFuneRejected)
2581 ricServiceUpdateAck->protocolIEs.list.count = elementCnt;
2582 ricServiceUpdateAck->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdateAcknowledge_IEs_t*);
2584 RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size);
2585 if(ricServiceUpdateAck->protocolIEs.list.array == NULLP)
2587 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
2591 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
2593 RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t));
2594 if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
2596 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
2600 if(arrIdx<elementCnt)
2602 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
2608 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2609 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2610 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_TransactionID;
2611 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
2613 if(ricRanFuncList.numOfRanFunAccepted)
2615 /* Accepted RAN function List */
2617 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
2618 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2619 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_RANfunctionsID_List;
2620 if(BuildRanFunctionAcceptedList(duDb, ricRanFuncList.numOfRanFunAccepted, ricRanFuncList.ranFunAcceptedList,\
2621 &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceUpdate)!=ROK)
2623 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
2628 if(ricRanFuncList.numOfRanFuneRejected)
2630 /* RAN Functions Rejected List */
2632 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsRejected;
2633 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2634 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_RANfunctionsIDcause_List;
2635 if(BuildRanFunctionRejectedList(ricRanFuncList.numOfRanFuneRejected, ricRanFuncList.ranFunRejectedList, \
2636 &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List)!=ROK)
2638 DU_LOG("\nERROR --> E2AP : Failed to build Ran function rejected list");
2644 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2645 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2647 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2649 /* Check encode results */
2650 if(encRetVal.encoded == ENCODE_FAIL)
2652 DU_LOG("\nERROR --> E2AP : Could not encode RIC service update Acknowledge structure (at %s)\n",\
2653 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2658 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Acknowledge\n");
2659 for(int i=0; i< encBufSize; i++)
2661 DU_LOG("%x",encBuf[i]);
2665 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
2667 DU_LOG("\nERROR --> E2AP : Sending RIC service update ack failed");
2673 FreeRicServiceUpdateAck(e2apMsg);
2677 /*******************************************************************
2679 * @brief process the RIC service update
2683 * Function : ProcRicserviceUpdate
2685 * Functionality: process the RIC service update
2687 * @return ROK - success
2690 ******************************************************************/
2692 void ProcRicServiceUpdate(uint32_t duId, RICserviceUpdate_t *ricServiceUpdate)
2694 RicTmpRanFunList ricRanFuncList;
2697 uint8_t duIdx = 0, elementCnt =0, arrIdx = 0;
2698 uint16_t ranFuncIdx = 0, failedRanFuncCount=0, recvdRanFuncCount=0;
2699 RANfunction_ItemIEs_t *ranFuncItemIe =NULL;
2700 RANfunction_Item_t *ranFuncItem =NULL;
2701 RANfunctionID_Item_t *ranFuncIdItem=NULL;
2702 RANfunctions_List_t *ranFuncList=NULL;
2703 RANfunctionsID_List_t *deleteList=NULL;
2704 RANfunctionID_ItemIEs_t *delRanFuncItem=NULL;
2706 SEARCH_DU_DB(duIdx, duId, duDb);
2709 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
2712 memset(&ricRanFuncList, 0, sizeof(RicTmpRanFunList));
2714 if(!ricServiceUpdate)
2716 DU_LOG("\nERROR --> E2AP : ricServiceUpdate pointer is null");
2720 if(!ricServiceUpdate->protocolIEs.list.array)
2722 DU_LOG("\nERROR --> E2AP : ricServiceUpdate array pointer is null");
2725 elementCnt = ricServiceUpdate->protocolIEs.list.count;
2726 for(arrIdx=0; arrIdx<ricServiceUpdate->protocolIEs.list.count; arrIdx++)
2728 if(!ricServiceUpdate->protocolIEs.list.array[arrIdx])
2730 DU_LOG("\nERROR --> E2AP : ricServiceUpdate array idx %d pointer is null",arrIdx);
2734 switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id)
2736 case ProtocolIE_IDE2_id_TransactionID:
2738 transId = ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
2740 if(transId < 0 || transId > 255)
2742 DU_LOG("\nERROR --> E2AP : Received invalid transId %d",transId);
2748 case ProtocolIE_IDE2_id_RANfunctionsAdded:
2750 ranFuncList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
2752 if(ranFuncList->list.array)
2754 for(ranFuncIdx=0;ranFuncIdx<ranFuncList->list.count; ranFuncIdx++)
2756 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx];
2757 ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
2759 /* Adding the ran function in temporary list */
2760 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].id = ranFuncItem->ranFunctionID;
2761 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].revisionCounter = ranFuncItem->ranFunctionRevision;
2762 ricRanFuncList.numOfRanFunAccepted++;
2764 /* Adding the new ran function in DB*/
2765 duDb->ranFunction[ranFuncItem->ranFunctionID-1].id = ranFuncItem->ranFunctionID;
2766 duDb->ranFunction[ranFuncItem->ranFunctionID-1].revisionCounter = ranFuncItem->ranFunctionRevision;
2767 duDb->numOfRanFunction++;
2769 /* Calculating total number of ran fuctions which are received for addition */
2770 recvdRanFuncCount++;
2776 case ProtocolIE_IDE2_id_RANfunctionsModified:
2779 ranFuncList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
2780 if(ranFuncList->list.array)
2782 for(ranFuncIdx = 0; ranFuncIdx< ranFuncList->list.count; ranFuncIdx++)
2784 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx];
2785 ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
2786 if(duDb->ranFunction[ranFuncItem->ranFunctionID-1].id != ranFuncItem->ranFunctionID)
2788 /* Calculating total number of ran fuctions which are not present */
2789 failedRanFuncCount++;
2791 /* Adding the ran function in temporary list */
2792 ricRanFuncList.ranFunRejectedList[ricRanFuncList.numOfRanFuneRejected].id = ranFuncItem->ranFunctionID;
2793 ricRanFuncList.numOfRanFuneRejected++;
2798 /* Adding the ran function in temporary list */
2799 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].id = ranFuncItem->ranFunctionID;
2800 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].revisionCounter = ranFuncItem->ranFunctionRevision;
2801 ricRanFuncList.numOfRanFunAccepted++;
2803 /* Updating the new ran function in DB*/
2804 duDb->ranFunction[ranFuncItem->ranFunctionID-1].revisionCounter = ranFuncItem->ranFunctionRevision;
2806 /* Calculating total number of ran fuctions which are received for modification */
2807 recvdRanFuncCount++;
2812 case ProtocolIE_IDE2_id_RANfunctionsDeleted:
2815 deleteList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
2816 if(deleteList->list.array)
2818 for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++)
2820 delRanFuncItem = (RANfunctionID_ItemIEs_t*) deleteList->list.array[ranFuncIdx];
2821 ranFuncIdItem = &delRanFuncItem->value.choice.RANfunctionID_Item;
2822 if(duDb->ranFunction[ranFuncIdItem->ranFunctionID-1].id == ranFuncIdItem->ranFunctionID)
2824 memset(&duDb->ranFunction[ranFuncIdItem->ranFunctionID-1], 0, sizeof(RanFunction));
2825 duDb->numOfRanFunction--;
2828 /* Calculating total number of ran fuctions which are received for deletion */
2829 recvdRanFuncCount++;
2837 DU_LOG("\nERROR --> E2AP : IE [%ld] is not supported",ricServiceUpdate->protocolIEs.list.array[arrIdx]->id);
2843 /* Sending RIC Service Update Failed if all RAN Functions received fail or if any IE processing fails
2844 * Else sending RIC Service Update Acknowledge */
2845 if((elementCnt > arrIdx) ||((recvdRanFuncCount > 0) && (recvdRanFuncCount == failedRanFuncCount)))
2847 if(BuildAndSendRicServiceUpdateFailure(duDb->duId, transId, CauseE2_PR_misc, CauseE2Misc_unspecified) != ROK)
2849 DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update Failure");
2855 if(BuildAndSendRicServiceUpdateAcknowledge(duDb, transId, ricRanFuncList) != ROK)
2857 DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update acknowledge");
2863 /*******************************************************************
2865 * @brief Processing RIC subscription failure from DU
2869 * Function : ProcRicSubscriptionFailure
2871 * Functionality: Processing RIC subscription failure from DU
2873 * @param ID of DU from which message was sent
2874 * RIC Subscription failure message
2875 * @return ROK - success
2878 ******************************************************************/
2879 uint8_t ProcRicSubscriptionFailure(uint32_t duId, RICsubscriptionFailure_t *ricSubscriptionFailure)
2881 uint8_t ieIdx = 0, duIdx = 0, subsIdx = 0;
2882 uint8_t ranFuncId = 0;
2883 bool ricReqIdDecoded = false;
2885 RanFunction *ranFuncDb = NULLP;
2886 RicRequestId ricReqId;
2887 RICsubscriptionFailure_IEs_t *ricSubsFailIe = NULLP;
2889 DU_LOG("\nINFO --> E2AP : Received RIC subscription failure");
2891 SEARCH_DU_DB(duIdx, duId, duDb);
2894 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
2898 memset(&ricReqId, 0, sizeof(RicRequestId));
2899 if(ricSubscriptionFailure)
2901 if(ricSubscriptionFailure->protocolIEs.list.array)
2903 for(ieIdx=0; ieIdx<ricSubscriptionFailure->protocolIEs.list.count; ieIdx++)
2905 if(ricSubscriptionFailure->protocolIEs.list.array[ieIdx])
2907 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[ieIdx];
2908 switch(ricSubscriptionFailure->protocolIEs.list.array[ieIdx]->id)
2910 case ProtocolIE_IDE2_id_RICrequestID:
2912 ricReqId.requestorId = ricSubsFailIe->value.choice.RICrequestID.ricRequestorID;
2913 ricReqId.instanceId = ricSubsFailIe->value.choice.RICrequestID.ricInstanceID;
2914 ricReqIdDecoded = true;
2917 case ProtocolIE_IDE2_id_RANfunctionID:
2919 ranFuncId = ricSubsFailIe->value.choice.RANfunctionID;
2920 if(duDb->ranFunction[ranFuncId-1].id == ranFuncId)
2922 ranFuncDb = &duDb->ranFunction[ranFuncId-1];
2926 case ProtocolIE_IDE2_id_CauseE2:
2928 /* No handling required as of now since this is a stub */
2935 /* Remove subscription entry from RAN Function */
2936 if(ranFuncDb && ricReqIdDecoded)
2938 for(subsIdx = 0; subsIdx < ranFuncDb->numOfSubscription; subsIdx++)
2940 if((ranFuncDb->subscriptionList[subsIdx].requestId.requestorId == ricReqId.requestorId) &&
2941 (ranFuncDb->subscriptionList[subsIdx].requestId.instanceId == ricReqId.instanceId))
2943 memset(&ranFuncDb->subscriptionList[subsIdx], 0, sizeof(RicSubscription));
2953 /*******************************************************************
2955 * @brief Handles received E2AP message and sends back response
2959 * Function : E2APMsgHdlr
2962 * - Decodes received E2AP control message
2963 * - Prepares response message, encodes and sends to SCTP
2966 * @return ROK - success
2969 * ****************************************************************/
2970 void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf)
2976 E2AP_PDU_t *e2apMsg;
2977 asn_dec_rval_t rval; /* Decoder return value */
2978 E2AP_PDU_t e2apasnmsg ;
2980 DU_LOG("\nINFO --> E2AP : Received E2AP message buffer");
2981 ODU_PRINT_MSG(mBuf, 0,0);
2983 /* Copy mBuf into char array to decode it */
2984 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
2985 RIC_ALLOC(recvBuf, (Size)recvBufLen);
2987 if(recvBuf == NULLP)
2989 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
2992 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
2994 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
2998 DU_LOG("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
2999 for(i=0; i< recvBufLen; i++)
3001 DU_LOG("%x",recvBuf[i]);
3004 /* Decoding flat buffer into E2AP messsage */
3005 e2apMsg = &e2apasnmsg;
3006 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
3008 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
3009 RIC_FREE(recvBuf, (Size)recvBufLen);
3011 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
3013 DU_LOG("\nERROR --> E2AP : ASN decode failed");
3017 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3019 switch(e2apMsg->present)
3021 case E2AP_PDU_PR_initiatingMessage:
3023 switch(e2apMsg->choice.initiatingMessage->value.present)
3025 case InitiatingMessageE2__value_PR_E2setupRequest:
3027 DU_LOG("\nINFO --> E2AP : E2 setup request received");
3028 ProcE2SetupReq(duId, &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest);
3031 case InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate:
3033 DU_LOG("\nINFO --> E2AP : E2 node config update received");
3034 BuildAndSendE2NodeConfigUpdateAck(*duId);
3037 case InitiatingMessageE2__value_PR_ResetRequestE2:
3039 DU_LOG("\nINFO --> E2AP : E2 Reset Request received");
3040 ProcE2ResetReq(*duId, &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2);
3043 case InitiatingMessageE2__value_PR_RICindication:
3045 DU_LOG("\nINFO --> E2AP : RIC Indication Acknowledged");
3048 case InitiatingMessageE2__value_PR_RICserviceUpdate:
3050 DU_LOG("\nINFO --> E2AP : RIC Service update received");
3051 ProcRicServiceUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate);
3057 DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]", \
3058 e2apMsg->choice.initiatingMessage->value.present);
3061 }/* End of switch(initiatingMessage) */
3064 case E2AP_PDU_PR_successfulOutcome:
3066 switch(e2apMsg->choice.successfulOutcome->value.present)
3068 case SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse:
3070 ProcRicSubscriptionResponse(*duId, \
3071 &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse);
3076 DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]", \
3077 e2apMsg->choice.successfulOutcome->value.present);
3084 case E2AP_PDU_PR_unsuccessfulOutcome:
3086 switch(e2apMsg->choice.successfulOutcome->value.present)
3088 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionFailure:
3090 ProcRicSubscriptionFailure(*duId, \
3091 &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure);
3096 DU_LOG("\nERROR --> E2AP : Invalid type of unsuccessfulOutcome message [%d]", \
3097 e2apMsg->choice.unsuccessfulOutcome->value.present);
3105 DU_LOG("\nERROR --> E2AP : Invalid type message type ");
3109 }/* End of switch(e2apMsg->present) */
3110 } /* End of E2APMsgHdlr */
3113 /**********************************************************************
3115 **********************************************************************/