1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
5 # Licensed under the Apache License, Version 2.0 (the "License"); #
6 # you may not use this file except in compliance with the License. #
7 # You may obtain a copy of the License at #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
11 # Unless required by applicable law or agreed to in writing, software #
12 # distributed under the License is distributed on an "AS IS" BASIS, #
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
14 # See the License for the specific language governing permissions and #
15 # limitations under the License. #
16 ################################################################################
17 *******************************************************************************/
19 /* This file contains E2AP message handler functions */
20 #include "common_def.h"
21 #include "OCTET_STRING.h"
22 #include "BIT_STRING.h"
23 #include "odu_common_codec.h"
24 #include "ric_stub_sctp.h"
26 #include "ric_e2ap_msg_hdl.h"
27 #include "GlobalE2node-gNB-ID.h"
28 #include "ProtocolIE-FieldE2.h"
29 #include "InitiatingMessageE2.h"
30 #include "SuccessfulOutcomeE2.h"
31 #include "UnsuccessfulOutcomeE2.h"
34 #include "E2nodeComponentInterfaceF1.h"
35 #include "E2SM-KPM-RANfunction-Description.h"
36 #include "RANfunction-Name.h"
37 #include "RIC-EventTriggerStyle-Item.h"
38 #include "RIC-ReportStyle-Item.h"
39 #include "MeasurementInfo-Action-Item.h"
41 /*******************************************************************
43 * @brief Assigns new transaction id to RIC initiated procedure
47 * Function : assignTransactionId
49 * Functionality: Assigns new transaction id to a RIC initiated
52 * @params[in] Region region
54 * @return ROK - success
57 * ****************************************************************/
59 uint8_t assignTransactionId(DuDb *duDb)
61 uint8_t currTransId = duDb->ricTransIdCounter;
63 /* Update to next valid value */
64 duDb->ricTransIdCounter++;
65 if(duDb->ricTransIdCounter == MAX_NUM_TRANSACTION)
66 duDb->ricTransIdCounter = 0;
71 /*******************************************************************
73 * @brief Sends E2 msg over SCTP
77 * Function : SendE2APMsg
79 * Functionality: Sends E2 msg over SCTP
81 * @params[in] Region region
83 * @return ROK - success
86 * ****************************************************************/
88 uint8_t SendE2APMsg(Region region, Pool pool, uint32_t duId)
92 if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
94 if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
96 ODU_PRINT_MSG(mBuf, 0,0);
98 if(sctpSend(duId, mBuf) != ROK)
100 DU_LOG("\nERROR --> E2AP : SCTP Send for E2 failed");
101 ODU_PUT_MSG_BUF(mBuf);
107 DU_LOG("\nERROR --> E2AP : ODU_ADD_POST_MSG_MULT failed");
108 ODU_PUT_MSG_BUF(mBuf);
111 ODU_PUT_MSG_BUF(mBuf);
115 DU_LOG("\nERROR --> E2AP : Failed to allocate memory");
122 /*******************************************************************
124 * @brief Builds Global RIC Id Params
128 * Function : BuildGlobalRicId
130 * Functionality: Building the Plmn and ric id
132 * @params[in] GlobalRIC_ID_t *ricId
133 * @return ROK - success
136 * ****************************************************************/
138 uint8_t BuildGlobalRicId(GlobalRIC_ID_t *ricId)
141 uint8_t byteSize = 3;
145 ricId->pLMN_Identity.size = byteSize * sizeof(uint8_t);
146 RIC_ALLOC(ricId->pLMN_Identity.buf, ricId->pLMN_Identity.size);
147 buildPlmnId(ricCb.ricCfgParams.plmn , ricId->pLMN_Identity.buf);
149 ricId->ric_ID.size = byteSize * sizeof(uint8_t);
150 RIC_ALLOC(ricId->ric_ID.buf, ricId->ric_ID.size);
151 fillBitString(&ricId->ric_ID, unused, byteSize, ricVal);
156 /*******************************************************************
158 * @brief deallocate the memory allocated in E2SetupResponse
162 * Function : FreeE2SetupRsp
164 * Functionality: deallocate the memory allocated in E2SetupResponse
166 * @params[in] E2AP_PDU_t *e2apMsg
169 * ****************************************************************/
170 void FreeE2SetupRsp(E2AP_PDU_t *e2apMsg)
172 uint8_t arrIdx = 0, e2NodeConfigIdx=0, ranFuncIdx=0;
173 RANfunctionsID_List_t *ranFuncAddedList;
174 E2setupResponse_t *e2SetupRsp;
175 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItemIe;
176 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList;
177 E2nodeComponentInterfaceF1_t *f1InterfaceInfo;
181 if(e2apMsg->choice.successfulOutcome)
183 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
184 if(e2SetupRsp->protocolIEs.list.array)
186 for(arrIdx=0; arrIdx<e2SetupRsp->protocolIEs.list.count; arrIdx++)
188 switch(e2SetupRsp->protocolIEs.list.array[arrIdx]->id)
190 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
192 ranFuncAddedList= &e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
193 if(ranFuncAddedList->list.array)
195 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
197 if(ranFuncAddedList->list.array[ranFuncIdx])
199 RIC_FREE(ranFuncAddedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
202 RIC_FREE(ranFuncAddedList->list.array, ranFuncAddedList->list.size);
206 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
208 e2NodeConfigAdditionAckList =&e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
209 if(e2NodeConfigAdditionAckList->list.count)
211 for(e2NodeConfigIdx=0; e2NodeConfigIdx<e2NodeConfigAdditionAckList->list.count; e2NodeConfigIdx++)
213 e2NodeAddAckItemIe = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[e2NodeConfigIdx];
214 if(e2NodeAddAckItemIe)
216 f1InterfaceInfo = e2NodeAddAckItemIe->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
219 RIC_FREE(f1InterfaceInfo->gNB_DU_ID.buf, f1InterfaceInfo->gNB_DU_ID.size);
220 RIC_FREE(f1InterfaceInfo, sizeof(E2nodeComponentInterfaceF1_t));
222 RIC_FREE(e2NodeAddAckItemIe, sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
225 RIC_FREE(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
230 RIC_FREE(e2SetupRsp->protocolIEs.list.array[arrIdx], sizeof(E2setupResponseIEs_t));
232 RIC_FREE(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
234 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
236 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
240 /*******************************************************************
242 * @brief Build E2node Component config addition ack list
246 * Function : BuildE2nodeComponentConfigAdditionAck
248 * Functionality: deallocate the memory allocated in E2SetupResponse
250 * @params[in] E2nodeComponentConfigAdditionAck_List_t
251 * *e2NodeConfigAdditionAckList
253 * @return ROK - success
255 * ****************************************************************/
257 uint8_t BuildE2nodeComponentConfigAdditionAck(E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList, DuDb *duDb)
260 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem;
262 e2NodeConfigAdditionAckList->list.count = 1;
263 e2NodeConfigAdditionAckList->list.size = e2NodeConfigAdditionAckList->list.count * sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t*);
264 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
265 if(e2NodeConfigAdditionAckList->list.array == NULLP)
267 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
271 for(arrIdx = 0; arrIdx< e2NodeConfigAdditionAckList->list.count; arrIdx++)
273 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
274 if(e2NodeConfigAdditionAckList->list.array[arrIdx] == NULLP)
276 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
280 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[0];
281 e2NodeAddAckItem->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck_Item;
282 e2NodeAddAckItem->criticality = CriticalityE2_reject;
283 e2NodeAddAckItem->value.present = E2nodeComponentConfigAdditionAck_ItemIEs__value_PR_E2nodeComponentConfigAdditionAck_Item;
284 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentInterfaceType = duDb->e2NodeComponent.interfaceType;
286 /* >E2 Node Component ID */
287 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
288 RIC_ALLOC(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
289 sizeof(E2nodeComponentInterfaceF1_t));
290 if(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1 == NULLP)
292 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
295 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
296 RIC_ALLOC(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
297 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
299 if(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
301 DU_LOG("\nERROR -->list. E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
304 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0] = duDb->e2NodeComponent.componentId;
306 /* >E2 Node Component Configuration Acknowledge*/
307 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentConfigurationAck.updateOutcome = \
308 E2nodeComponentConfigurationAck__updateOutcome_success;
313 /*******************************************************************
315 * @brief Build RAN function added list
319 * Function : BuildRanFunctionAddedList
321 * Functionality: Build RAN function added list
322 * ->For ProcedureCodeE2_id_E2setup or ProcedureCodeE2_id_RICserviceQuery
323 * we add all the RAN Function list which is present in RIC database.
324 * ->For any other procedures, we just fill the RAN functions whose ID
325 * is present in the recvList
329 * Count of ran functions to be added in the list
330 * Received list of RAN functions
334 * @return ROK - success
336 * ****************************************************************/
338 uint8_t BuildRanFunctionAddedList(DuDb *duDb, uint8_t count, RanFunction *ranFunToBeAdded, RANfunctionsID_List_t *ranFuncAddedList, uint8_t procedureCode)
340 uint8_t ranFuncIdx = 0;
341 RANfunctionID_ItemIEs_t *ranFuncAddedItemIe;
343 /* For ProcedureCodeE2_id_E2setup and ProcedureCodeE2_id_RICserviceQuery,
344 * the number of RAN function list items is equal to the number of
345 * ran function entries stored in the database.
346 * For any other procedure, the RAN function list count is equal
347 * to the count of ran functions obtained from the function's caller */
349 if((procedureCode == ProcedureCodeE2_id_RICserviceQuery)||(procedureCode == ProcedureCodeE2_id_E2setup))
350 ranFuncAddedList->list.count = duDb->numOfRanFunction;
352 ranFuncAddedList->list.count = count;
354 ranFuncAddedList->list.size = ranFuncAddedList->list.count*sizeof(RANfunctionID_ItemIEs_t*);
355 RIC_ALLOC(ranFuncAddedList->list.array, ranFuncAddedList->list.size);
356 if(ranFuncAddedList->list.array)
358 for(ranFuncIdx = 0; ranFuncIdx< ranFuncAddedList->list.count; ranFuncIdx++)
360 RIC_ALLOC(ranFuncAddedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
361 if(ranFuncAddedList->list.array[ranFuncIdx] == NULLP)
363 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array item");
366 ranFuncAddedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAddedList->list.array[ranFuncIdx];
367 ranFuncAddedItemIe->id = ProtocolIE_IDE2_id_RANfunctionID_Item;
368 ranFuncAddedItemIe->criticality= CriticalityE2_ignore;
369 ranFuncAddedItemIe->value.present = RANfunctionID_ItemIEs__value_PR_RANfunctionID_Item;
370 if((procedureCode == ProcedureCodeE2_id_RICserviceQuery)||(procedureCode == ProcedureCodeE2_id_E2setup))
372 /* filling the RAN function information with the help of DuDb */
373 ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionID = duDb->ranFunction[ranFuncIdx].id;
374 ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision= duDb->ranFunction[ranFuncIdx].revisionCounter;
378 /* filling the the RAN function information with the help received list of RAN functions */
379 ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionID = ranFunToBeAdded[ranFuncIdx].id;
380 ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision= ranFunToBeAdded[ranFuncIdx].revisionCounter;
386 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array");
392 /*******************************************************************
394 * @brief Builds and sends the E2SetupResponse
398 * Function : BuildAndSendE2SetupRsp
400 * Functionality: Constructs the F1SetupResponse message and sends
401 * it back to the DU through SCTP.
403 * @params[in] void **buf,Buffer to which encoded pattern is written into
404 * @params[in] int *size,size of buffer
406 * @return ROK - success
409 * ****************************************************************/
411 uint8_t BuildAndSendE2SetupRsp(DuDb *duDb, uint8_t transId)
413 E2AP_PDU_t *e2apMsg = NULL;
414 E2setupResponse_t *e2SetupRsp;
415 asn_enc_rval_t encRetVal;
418 bool memAllocFailed = false;
420 DU_LOG("\nINFO --> E2AP : Building E2 Setup Response\n");
423 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
426 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
429 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
430 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
431 if(e2apMsg->choice.successfulOutcome == NULLP)
433 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
437 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
438 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
439 e2apMsg->choice.successfulOutcome->value.present = \
440 SuccessfulOutcomeE2__value_PR_E2setupResponse;
441 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
444 /* Fill Accepted RAN function IE If Ran function information is stored in databse */
445 if(duDb->numOfRanFunction)
448 e2SetupRsp->protocolIEs.list.count = elementCnt;
449 e2SetupRsp->protocolIEs.list.size = elementCnt * sizeof(E2setupResponseIEs_t*);
451 RIC_ALLOC(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
452 if(e2SetupRsp->protocolIEs.list.array == NULLP)
454 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
458 for(idx=0; idx<elementCnt; idx++)
460 RIC_ALLOC(e2SetupRsp->protocolIEs.list.array[idx], sizeof(E2setupResponseIEs_t));
461 if(e2SetupRsp->protocolIEs.list.array[idx] == NULLP)
463 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
464 memAllocFailed = true;
469 if(memAllocFailed == true)
471 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
476 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_TransactionID;
477 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
478 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_TransactionID;
479 e2SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID = transId;
483 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_GlobalRIC_ID;
484 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
485 e2SetupRsp->protocolIEs.list.array[idx]->value.present = \
486 E2setupResponseIEs__value_PR_GlobalRIC_ID;
488 if(BuildGlobalRicId(&(e2SetupRsp->protocolIEs.list.array[idx]->value.choice.GlobalRIC_ID))!=ROK)
490 DU_LOG("\nERROR --> E2AP : Failed to build Global Ric Id");
494 if(duDb->numOfRanFunction)
496 /* Accepted RAN function Id */
498 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
499 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
500 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_RANfunctionsID_List;
501 if(BuildRanFunctionAddedList(duDb, 0, NULL, &e2SetupRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_E2setup)!=ROK)
503 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
508 /* E2 Node Component Configuration Addition Acknowledge List*/
510 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck;
511 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
512 e2SetupRsp->protocolIEs.list.array[idx]->value.present = \
513 E2setupResponseIEs__value_PR_E2nodeComponentConfigAdditionAck_List;
514 if(BuildE2nodeComponentConfigAdditionAck(&e2SetupRsp->protocolIEs.list.array[idx]->value.choice.E2nodeComponentConfigAdditionAck_List, duDb)!=ROK)
516 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config addition ack list");
520 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
521 memset(encBuf, 0, ENC_BUF_MAX_LEN);
523 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
525 /* Check encode results */
526 if(encRetVal.encoded == ENCODE_FAIL)
528 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupResponse structure (at %s)\n",\
529 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
534 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupResponse\n");
535 for(int i=0; i< encBufSize; i++)
537 DU_LOG("%x",encBuf[i]);
541 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
543 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Response failed");
549 FreeE2SetupRsp(e2apMsg);
550 BuildAndSendRicSubscriptionReq(duDb->duId);
554 /*******************************************************************
556 * @brief Builds Ric Request Id
560 * Function : BuildRicRequestId
562 * Functionality: Building the Ric Request Id
564 * @params[in] RICrequestID_t *ricReqId
565 * @return ROK - success
568 * ****************************************************************/
570 uint8_t BuildRicRequestId(RICrequestID_t *ricReqId)
573 if(ricReqId != NULLP)
575 ricReqId->ricRequestorID = 1;
576 ricReqId->ricInstanceID = 1;
581 /*******************************************************************
583 * @brief Fills Ric Action To be Setup Item
587 * Function : fillSetupItems
589 * Functionality: Filling ricAction Id, RicActionType
591 * @params[in] RICaction_ToBeSetup_Item_t *setupItems
592 * @return pointer of type RICaction_ToBeSetup_Item_t
594 * ****************************************************************/
596 RICaction_ToBeSetup_Item_t* fillSetupItems(RICaction_ToBeSetup_Item_t *setupItems)
598 if(setupItems != NULLP)
600 setupItems->ricActionID = 0;
601 setupItems->ricActionType = RICactionType_report;
607 /*******************************************************************
609 * @brief Fills RIC Subscription Details Item List
613 * Function : fillSubsDetails
615 * Functionality: Fill the RIC Subscription Details Items List
617 * @params[in] RICaction_ToBeSetup_ItemIEs_t *items
618 * @return ROK - success
621 * ****************************************************************/
623 uint8_t fillSubsDetails(RICaction_ToBeSetup_ItemIEs_t *items)
627 items->id = ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item;
628 items->criticality = CriticalityE2_ignore;
629 items->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
630 fillSetupItems(&(items->value.choice.RICaction_ToBeSetup_Item));
635 /*******************************************************************
637 * @brief builds RIC Subscription Details
641 * Function : BuildsRicSubsDetails
643 * Functionality: Builds the RIC Subscription Details
645 * @params[in] RICsubscriptionDetails_t *subsDetails
646 * @return ROK - success
649 * ****************************************************************/
651 uint8_t BuildRicSubsDetails(RICsubscriptionDetails_t *subsDetails)
656 if(subsDetails != NULLP)
658 /* Octet string to be build here */
659 /* Sending PLMN as Octect string */
660 uint8_t byteSize = 3;
661 subsDetails->ricEventTriggerDefinition.size = byteSize * sizeof(uint8_t);
662 RIC_ALLOC(subsDetails->ricEventTriggerDefinition.buf, subsDetails->ricEventTriggerDefinition.size);
663 buildPlmnId(ricCb.ricCfgParams.plmn, subsDetails->ricEventTriggerDefinition.buf);
665 subsDetails->ricAction_ToBeSetup_List.list.count = elementCnt;
666 subsDetails->ricAction_ToBeSetup_List.list.size = \
667 elementCnt * sizeof(RICaction_ToBeSetup_ItemIEs_t);
668 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array, \
669 subsDetails->ricAction_ToBeSetup_List.list.size);
670 if(subsDetails->ricAction_ToBeSetup_List.list.array == NULLP)
672 DU_LOG("\nERROR --> E2AP : Memory allocation for RICactionToBeSetup Items failed");
675 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array[0],\
676 sizeof(RICaction_ToBeSetup_ItemIEs_t));
677 fillSubsDetails(subsDetails->ricAction_ToBeSetup_List.list.array[0]);
682 /*******************************************************************
684 * @brief Builds and Send the RicSubscriptionReq
688 * Function : BuildAndSendRicSubscriptionReq
690 * Functionality:Fills the RicSubscriptionReq
692 * @return ROK - success
695 ******************************************************************/
697 uint8_t BuildAndSendRicSubscriptionReq(uint32_t duId)
700 E2AP_PDU_t *e2apRicMsg = NULL;
701 RICsubscriptionRequest_t *ricSubscriptionReq;
706 asn_enc_rval_t encRetVal; /* Encoder return value */
708 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Request\n");
710 RIC_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
711 if(e2apRicMsg == NULLP)
713 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
717 e2apRicMsg->present = E2AP_PDU_PR_initiatingMessage;
718 RIC_ALLOC(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
719 if(e2apRicMsg->choice.initiatingMessage == NULLP)
721 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
722 RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
725 e2apRicMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscription;
726 e2apRicMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
727 e2apRicMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionRequest;
729 RIC_ALLOC(ricSubscriptionReq, sizeof(RICsubscriptionRequest_t));
730 ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
733 ricSubscriptionReq->protocolIEs.list.count = elementCnt;
734 ricSubscriptionReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionRequest_IEs_t);
736 /* Initialize the subscription members */
737 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array, \
738 ricSubscriptionReq->protocolIEs.list.size);
739 if(ricSubscriptionReq->protocolIEs.list.array == NULLP)
741 DU_LOG("\nERROR --> E2AP : Memory allocation for RICSubscriptionRequestIEs failed");
742 RIC_FREE(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
743 RIC_FREE(e2apRicMsg, (Size)sizeof(E2AP_PDU_t));
747 for(idx=0; idx<elementCnt; idx++)
749 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array[idx],\
750 sizeof(RICsubscriptionRequest_IEs_t));
751 if(ricSubscriptionReq->protocolIEs.list.array[idx] == NULLP)
753 for(ieId=0; ieId<idx; ieId++)
755 RIC_FREE(ricSubscriptionReq->protocolIEs.list.array[ieId],\
756 sizeof(RICsubscriptionRequest_IEs_t));
758 RIC_FREE(ricSubscriptionReq->protocolIEs.list.array,\
759 ricSubscriptionReq->protocolIEs.list.size);
760 RIC_FREE(e2apRicMsg->choice.initiatingMessage, \
761 sizeof(InitiatingMessageE2_t));
762 RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
767 /* Filling RIC Request Id */
769 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
770 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
771 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
772 RICsubscriptionRequest_IEs__value_PR_RICrequestID;
774 BuildRicRequestId(&ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICrequestID);
777 /* Filling RAN Function Id */
779 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
780 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
781 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
782 RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
783 ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID = 1;
786 /* Filling RIC Subscription Details */
788 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICsubscriptionDetails;
789 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
790 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
791 RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails;
793 BuildRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails));
796 /* Prints the Msg formed */
797 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
799 memset(encBuf, 0, ENC_BUF_MAX_LEN);
801 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf,\
803 if(encRetVal.encoded == ENCODE_FAIL)
805 DU_LOG("\nERROR --> E2AP : Could not encode RicSubscriptionRequest structure (at %s)\n",\
806 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
811 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionRequest\n");
812 for(int i=0; i< encBufSize; i++)
814 DU_LOG("%x",encBuf[i]);
820 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
822 DU_LOG("\nERROR --> E2AP : Sending RIC subscription Request failed");
829 /*******************************************************************
831 * @brief Process RicSubscriptionResponse
835 * Function : ProcRicSubscriptionRsp
837 * Functionality: Processes RicSubscriptionRsp
841 ******************************************************************/
843 void ProcRicSubscriptionResponse(uint32_t duId)
848 DU_LOG("\nINFO --> E2AP : RICsubscriptionResponse Msg Acknowledged");
850 SEARCH_DU_DB(duIdx, duId, duDb);
852 duDb->ricSubscribedToDu = true;
855 /*******************************************************************
857 * @brief deallocate the memory allocated in E2SetupFailure
861 * Function : FreeE2SetupFailure
863 * Functionality: deallocate the memory allocated in E2SetupFailure
865 * @params[in] E2AP_PDU_t *e2apMsg
868 * ****************************************************************/
869 void FreeE2SetupFailure(E2AP_PDU_t *e2apMsg)
872 E2setupFailure_t *e2SetupFail;
876 if(e2apMsg->choice.unsuccessfulOutcome)
878 e2SetupFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
879 if(e2SetupFail->protocolIEs.list.array)
881 for(arrIdx=0; arrIdx<e2SetupFail->protocolIEs.list.count; arrIdx++)
883 RIC_FREE(e2SetupFail->protocolIEs.list.array[arrIdx], sizeof(E2setupFailureIEs_t));
885 RIC_FREE(e2SetupFail->protocolIEs.list.array, e2SetupFail->protocolIEs.list.size);
887 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
889 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
893 /*******************************************************************
895 * @brief Buld and send the E2 Setup failure
899 * Function : BuildAndSendE2SetupFailure
902 * - Buld and send the E2 Setup failure
903 * @return ROK - success
906 * ****************************************************************/
908 uint8_t BuildAndSendE2SetupFailure(uint32_t duId, uint8_t transId)
910 E2AP_PDU_t *e2apMsg = NULL;
911 E2setupFailure_t *e2SetupFailure;
912 asn_enc_rval_t encRetVal;
915 bool memAllocFailed = false;
917 DU_LOG("\nINFO --> E2AP : Building E2 Setup failure\n");
920 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
923 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
926 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
927 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
928 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
930 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
934 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
935 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
936 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2setupFailure;
937 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
940 e2SetupFailure->protocolIEs.list.count = elementCnt;
941 e2SetupFailure->protocolIEs.list.size = elementCnt * sizeof(struct E2setupFailureIEs *);
943 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array, e2SetupFailure->protocolIEs.list.size);
944 if(e2SetupFailure->protocolIEs.list.array == NULLP)
946 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
950 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
952 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array[arrIdx], sizeof(struct E2setupFailureIEs));
953 if(e2SetupFailure->protocolIEs.list.array[arrIdx] == NULLP)
955 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
956 memAllocFailed = true;
961 if(memAllocFailed == true)
963 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
969 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
970 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
971 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID;
972 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
975 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
976 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
977 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2;
978 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = CauseE2_PR_protocol;
979 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.protocol = CauseE2Protocol_unspecified;
982 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
983 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
984 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2;
985 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
987 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
988 memset(encBuf, 0, ENC_BUF_MAX_LEN);
990 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
992 /* Check encode results */
993 if(encRetVal.encoded == ENCODE_FAIL)
995 DU_LOG("\nERROR --> E2AP : Could not encode E2 Setup failure structure (at %s)\n",\
996 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1001 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Setup Failure\n");
1002 for(int i=0; i< encBufSize; i++)
1004 DU_LOG("%x",encBuf[i]);
1008 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
1010 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Failure failed");
1016 FreeE2SetupFailure(e2apMsg);
1019 /*******************************************************************
1021 * @brief process the e2setup request
1025 * Function : ProcE2SetupReq
1027 * Functionality: process the e2setup request
1029 * @return ROK - success
1032 ******************************************************************/
1034 uint8_t ProcE2SetupReq(uint32_t *duId, E2setupRequest_t *e2SetupReq)
1036 uint8_t arrIdx = 0, e2NodeAddListIdx =0, duIdx = 0, transId =0, ranFuncIdx;
1038 E2nodeComponentConfigAddition_List_t *e2NodeAddList;
1039 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem;
1040 RANfunction_ItemIEs_t *ranFuncItemIe;
1041 RANfunction_Item_t *ranFunItem;
1042 RANfunctions_List_t *ranFunctionsList;
1046 if(e2SetupReq->protocolIEs.list.array)
1048 for(arrIdx=0; arrIdx<e2SetupReq->protocolIEs.list.count; arrIdx++)
1050 if(e2SetupReq->protocolIEs.list.array[arrIdx])
1052 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
1054 case ProtocolIE_IDE2_id_TransactionID:
1056 transId = e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
1059 case ProtocolIE_IDE2_id_GlobalE2node_ID:
1061 if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID)
1063 *duId =e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID->buf[0];
1065 SEARCH_DU_DB(duIdx, *duId, duDb);
1068 duDb = &ricCb.duInfo[ricCb.numDu];
1071 memset(duDb, 0, sizeof(DuDb));
1076 case ProtocolIE_IDE2_id_RANfunctionsAdded:
1079 ranFunctionsList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
1081 if(ranFunctionsList->list.array)
1083 for(ranFuncIdx=0;ranFuncIdx<ranFunctionsList->list.count; ranFuncIdx++)
1085 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
1086 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
1087 duDb->ranFunction[ranFunItem->ranFunctionID-1].id = ranFunItem->ranFunctionID;
1088 duDb->ranFunction[ranFunItem->ranFunctionID-1].revisionCounter = ranFunItem->ranFunctionRevision;
1089 duDb->numOfRanFunction++;
1094 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
1096 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
1097 if(e2NodeAddList->list.array)
1099 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
1101 if(e2NodeAddList->list.array[e2NodeAddListIdx])
1103 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
1104 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
1105 e2nodeComponentInterfaceTypeF1)
1107 duDb->e2NodeComponent.interfaceType = F1;
1108 duDb->e2NodeComponent.componentId = e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0];
1123 if(BuildAndSendE2SetupRsp(duDb, transId) !=ROK)
1125 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 setup response");
1131 /*******************************************************************
1133 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
1137 * Function : FreeE2NodeConfigUpdate
1140 * - freeing the memory allocated for E2nodeConfigurationUpdate
1142 * @params[in] E2AP_PDU_t *e2apMsg
1143 * @return ROK - success
1146 * ****************************************************************/
1147 void FreeE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg)
1150 E2nodeConfigurationUpdate_t *e2NodeConfigUpdateAck;
1152 if(e2apMsg != NULLP)
1154 if(e2apMsg->choice.successfulOutcome != NULLP)
1156 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
1157 if(e2NodeConfigUpdateAck->protocolIEs.list.array != NULLP)
1159 for(arrIdx = 0; arrIdx < e2NodeConfigUpdateAck->protocolIEs.list.count; arrIdx++)
1161 RIC_FREE(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_t));
1163 RIC_FREE(e2NodeConfigUpdateAck->protocolIEs.list.array, e2NodeConfigUpdateAck->protocolIEs.list.size);
1165 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1167 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1171 /*******************************************************************
1173 * @brief Buld and send the E2 node config update msg
1177 * Function : BuildAndSendE2NodeConfigUpdate
1180 * - Buld and send the E2 node config update msg
1181 * @return ROK - success
1184 * ****************************************************************/
1186 uint8_t BuildAndSendE2NodeConfigUpdateAck(uint32_t duId)
1188 uint8_t arrIdx = 0,elementCnt = 1;
1190 E2AP_PDU_t *e2apMsg = NULLP;
1191 E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck = NULLP;
1192 asn_enc_rval_t encRetVal; /* Encoder return value */
1194 DU_LOG("\nINFO --> E2AP : Building E2 Node config update Ack Message\n");
1197 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1198 if(e2apMsg == NULLP)
1200 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1203 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
1204 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1205 if(e2apMsg->choice.successfulOutcome == NULLP)
1207 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1208 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1212 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
1213 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
1214 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge;
1215 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
1217 e2NodeConfigUpdateAck->protocolIEs.list.count = elementCnt;
1218 e2NodeConfigUpdateAck->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t*);
1219 /* Initialize the Ric Indication members */
1220 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array, \
1221 e2NodeConfigUpdateAck->protocolIEs.list.size);
1222 if(e2NodeConfigUpdateAck->protocolIEs.list.array == NULLP)
1224 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdateAck failed");
1228 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
1230 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t));
1231 if(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
1234 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdateAck failed");
1241 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1242 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1243 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_TransactionID;
1244 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = TRANS_ID;
1247 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1249 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1251 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1253 if(encRetVal.encoded == ENCODE_FAIL)
1255 DU_LOG("\nERROR --> E2AP : Could not encode E2 Node config update ack structure (at %s)\n",\
1256 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1261 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node config update ack \n");
1262 for(int i=0; i< encBufSize; i++)
1264 DU_LOG("%x",encBuf[i]);
1270 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
1272 DU_LOG("\nERROR --> E2AP : Failed to send E2 Node config update ack ");
1279 FreeE2NodeConfigUpdateAck(e2apMsg);
1283 /*******************************************************************
1285 * @brief Deallocate the memory allocated for E2 Reset Response
1289 * Function : FreeE2ResetResponse
1292 * - freeing the memory allocated for E2ResetResponse
1294 * @params[in] E2AP_PDU_t *e2apMsg
1295 * @return ROK - success
1298 * ****************************************************************/
1299 void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
1302 ResetResponseE2_t *resetResponse;
1304 if(e2apMsg != NULLP)
1306 if(e2apMsg->choice.successfulOutcome != NULLP)
1308 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
1309 if(resetResponse->protocolIEs.list.array)
1311 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
1313 if(resetResponse->protocolIEs.list.array[ieIdx])
1315 RIC_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
1318 RIC_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
1320 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1322 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1326 /*******************************************************************
1328 * @brief Buld and send the E2 Reset Response msg
1332 * Function : BuildAndSendE2ResetResponse
1335 * - Buld and send the E2 Reset Response Message
1336 * @return ROK - success
1339 * ****************************************************************/
1340 uint8_t BuildAndSendResetResponse(uint32_t duId, uint8_t transId)
1342 uint8_t ieIdx = 0, elementCnt = 0;
1343 uint8_t ret = RFAILED;
1344 E2AP_PDU_t *e2apMsg = NULLP;
1345 ResetResponseE2_t *resetResponse;
1346 asn_enc_rval_t encRetVal; /* Encoder return value */
1348 DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
1351 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1352 if(e2apMsg == NULLP)
1354 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
1357 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
1359 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1360 if(e2apMsg->choice.successfulOutcome == NULLP)
1362 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
1363 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1367 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset;
1368 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
1369 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2;
1370 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
1373 resetResponse->protocolIEs.list.count = elementCnt;
1374 resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *);
1375 RIC_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
1376 if(!resetResponse->protocolIEs.list.array)
1378 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
1382 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
1384 RIC_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
1385 if(!resetResponse->protocolIEs.list.array[ieIdx])
1387 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
1391 if(ieIdx < elementCnt)
1395 resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1396 resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
1397 resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID;
1398 resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
1400 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1402 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1404 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
1405 if(encRetVal.encoded == ENCODE_FAIL)
1407 DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
1408 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1413 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
1414 for(int i=0; i< encBufSize; i++)
1416 DU_LOG("%x",encBuf[i]);
1421 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
1423 DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
1431 FreeE2ResetResponse(e2apMsg);
1435 /*******************************************************************
1437 * @brief process the E2 Reset Request
1441 * Function : ProcE2ResetReq
1443 * Functionality: Process E2 Reset Request
1445 * @return ROK - success
1448 ******************************************************************/
1450 uint8_t ProcE2ResetReq(uint32_t duId, ResetRequestE2_t *resetReq)
1452 uint8_t ieIdx = 0, duIdx = 0;
1453 uint8_t transId = 0, cause = 0;
1458 if(resetReq->protocolIEs.list.array)
1460 for(ieIdx=0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
1462 if(resetReq->protocolIEs.list.array[ieIdx])
1464 switch(resetReq->protocolIEs.list.array[ieIdx]->id)
1466 case ProtocolIE_IDE2_id_TransactionID:
1467 transId = resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
1469 case ProtocolIE_IDE2_id_CauseE2:
1470 DU_LOG("\nDEBUG --> E2AP : Reset reason %d", resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present);
1471 switch(resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present)
1473 case CauseE2_PR_NOTHING:
1475 case CauseE2_PR_ricRequest:
1476 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricRequest;
1478 case CauseE2_PR_ricService:
1479 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricService;
1481 case CauseE2_PR_e2Node:
1482 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.e2Node;
1484 case CauseE2_PR_transport:
1485 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.transport;
1487 case CauseE2_PR_protocol:
1488 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.protocol;
1490 case CauseE2_PR_misc:
1491 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.misc;
1494 DU_LOG("\nDEBUG --> E2AP : Reset cause %d", cause);
1501 BuildAndSendResetResponse(duId, transId);
1505 /*******************************************************************
1507 * @brief deallocate the memory allocated in building the
1508 * Service Query message
1512 * Function : FreeRicServiceQuery
1514 * Functionality: deallocate the memory allocated in building
1515 * Ric Service Query message
1517 * @params[in] E2AP_PDU_t *e2apMsg
1520 * ****************************************************************/
1522 void FreeRicServiceQuery(E2AP_PDU_t *e2apMsg)
1524 uint8_t arrIdx = 0, ranFuncIdx=0;
1525 RANfunctionsID_List_t *ranFuncAddedList;
1526 RICserviceQuery_t *ricServiceQuery;
1530 if(e2apMsg->choice.initiatingMessage)
1532 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
1533 if(ricServiceQuery->protocolIEs.list.array)
1535 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
1537 if(ricServiceQuery->protocolIEs.list.array[arrIdx])
1539 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
1541 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
1543 ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
1544 if(ranFuncAddedList->list.array)
1546 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
1548 RIC_FREE(ranFuncAddedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
1550 RIC_FREE(ranFuncAddedList->list.array, ranFuncAddedList->list.size);
1554 case RICserviceQuery_IEs__value_PR_TransactionID:
1559 RIC_FREE(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
1562 RIC_FREE(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
1564 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1566 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1570 /*******************************************************************
1572 * @brief build and send the ric service Query
1576 * Function : BuildAndSendRicServiceQuery
1578 * Functionality: build and send the ric service Query
1579 * @return ROK - success
1580 * RFAILED - Acknowledge
1582 ******************************************************************/
1584 uint8_t BuildAndSendRicServiceQuery(DuDb *duDb)
1588 uint8_t ret = RFAILED;
1589 bool memAllocFailed = false;
1590 E2AP_PDU_t *e2apMsg = NULL;
1591 asn_enc_rval_t encRetVal;
1592 RICserviceQuery_t *ricServiceQuery;
1594 DU_LOG("\nINFO --> E2AP : Building Ric service Query\n");
1597 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1598 if(e2apMsg == NULLP)
1600 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1603 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
1604 RIC_ALLOC(e2apMsg->choice.initiatingMessage , sizeof(struct InitiatingMessageE2));
1605 if(e2apMsg->choice.initiatingMessage == NULLP)
1607 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1611 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceQuery;
1612 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
1613 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceQuery;
1614 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
1617 /* Fill Accepted RAN function IE If Ran function information is stored in databse */
1618 if(duDb->numOfRanFunction)
1621 ricServiceQuery->protocolIEs.list.count = elementCnt;
1622 ricServiceQuery->protocolIEs.list.size = elementCnt * sizeof(RICserviceQuery_IEs_t*);
1624 RIC_ALLOC(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
1625 if(ricServiceQuery->protocolIEs.list.array == NULLP)
1627 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
1631 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
1633 RIC_ALLOC(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
1634 if(ricServiceQuery->protocolIEs.list.array[arrIdx] == NULLP)
1636 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
1637 memAllocFailed = true;
1641 if(memAllocFailed == true)
1643 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
1649 ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1650 ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1651 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_TransactionID;
1652 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = assignTransactionId(duDb);
1654 if(duDb->numOfRanFunction)
1656 /* Accepted RAN function Id */
1658 ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
1659 ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1660 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_RANfunctionsID_List;
1661 if(BuildRanFunctionAddedList(duDb, 0, NULL, &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceQuery)!=ROK)
1663 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
1668 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1669 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1671 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
1673 /* Check encode results */
1674 if(encRetVal.encoded == ENCODE_FAIL)
1676 DU_LOG("\nERROR --> E2AP : Could not encode RIC service Query structure (at %s)\n",\
1677 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1682 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service Query\n");
1683 for(int i=0; i< encBufSize; i++)
1685 DU_LOG("%x",encBuf[i]);
1689 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
1691 DU_LOG("\nERROR --> E2AP : Sending of RIC service Query failed");
1698 FreeRicServiceQuery(e2apMsg);
1702 /*******************************************************************
1704 * @brief Handles received E2AP message and sends back response
1708 * Function : E2APMsgHdlr
1711 * - Decodes received E2AP control message
1712 * - Prepares response message, encodes and sends to SCTP
1715 * @return ROK - success
1718 * ****************************************************************/
1719 void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf)
1725 E2AP_PDU_t *e2apMsg;
1726 asn_dec_rval_t rval; /* Decoder return value */
1727 E2AP_PDU_t e2apasnmsg ;
1729 DU_LOG("\nINFO --> E2AP : Received E2AP message buffer");
1730 ODU_PRINT_MSG(mBuf, 0,0);
1732 /* Copy mBuf into char array to decode it */
1733 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
1734 RIC_ALLOC(recvBuf, (Size)recvBufLen);
1736 if(recvBuf == NULLP)
1738 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
1741 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
1743 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
1747 DU_LOG("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
1748 for(i=0; i< recvBufLen; i++)
1750 DU_LOG("%x",recvBuf[i]);
1753 /* Decoding flat buffer into E2AP messsage */
1754 e2apMsg = &e2apasnmsg;
1755 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
1757 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
1758 RIC_FREE(recvBuf, (Size)recvBufLen);
1760 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
1762 DU_LOG("\nERROR --> E2AP : ASN decode failed");
1766 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1768 switch(e2apMsg->present)
1770 case E2AP_PDU_PR_initiatingMessage:
1772 switch(e2apMsg->choice.initiatingMessage->value.present)
1774 case InitiatingMessageE2__value_PR_E2setupRequest:
1776 DU_LOG("\nINFO --> E2AP : E2 setup request received");
1777 ProcE2SetupReq(duId, &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest);
1780 case InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate:
1782 DU_LOG("\nINFO --> E2AP : E2 node config update received");
1783 BuildAndSendE2NodeConfigUpdateAck(*duId);
1786 case InitiatingMessageE2__value_PR_ResetRequestE2:
1788 DU_LOG("\nINFO --> E2AP : E2 Reset Request received");
1789 ProcE2ResetReq(*duId, &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2);
1792 case InitiatingMessageE2__value_PR_RICindication:
1794 DU_LOG("\nINFO --> E2AP : RIC Indication Acknowledged");
1799 DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]",e2apMsg->choice.initiatingMessage->value.present);
1802 }/* End of switch(initiatingMessage) */
1805 case E2AP_PDU_PR_successfulOutcome:
1807 switch(e2apMsg->choice.successfulOutcome->value.present)
1809 case SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse:
1811 ProcRicSubscriptionResponse(*duId);
1816 DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]",e2apMsg->choice.successfulOutcome->value.present);
1825 DU_LOG("\nERROR --> E2AP : Invalid type message type ");
1829 }/* End of switch(e2apMsg->present) */
1830 } /* End of E2APMsgHdlr */
1833 /**********************************************************************
1835 **********************************************************************/