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 *******************************************************************************/
18 #include "common_def.h"
24 #include "du_app_mac_inf.h"
25 #include "du_app_rlc_inf.h"
26 #include "du_e2ap_mgr.h"
27 #include "du_e2ap_msg_hdl.h"
30 #include "du_mgr_main.h"
32 #include "GlobalE2node-gNB-ID.h"
33 #include "ProtocolIE-FieldE2.h"
34 #include "E2setupRequest.h"
35 #include "InitiatingMessageE2.h"
36 #include "SuccessfulOutcomeE2.h"
37 #include "UnsuccessfulOutcomeE2.h"
39 #include "odu_common_codec.h"
40 #include "E2nodeComponentInterfaceF1.h"
41 #include "E2setupRequest.h"
42 #include "du_e2_conversions.h"
43 #include "E2SM-KPM-RANfunction-Description.h"
44 #include "RANfunction-Name.h"
45 #include "RIC-EventTriggerStyle-Item.h"
46 #include "RIC-ReportStyle-Item.h"
47 #include "MeasurementInfo-Action-Item.h"
48 #include "E2SM-KPM-EventTriggerDefinition.h"
49 #include "E2SM-KPM-EventTriggerDefinition-Format1.h"
50 #include "E2SM-KPM-ActionDefinition.h"
51 #include "E2SM-KPM-ActionDefinition-Format1.h"
52 #include "MeasurementInfoItem.h"
53 #include "RANfunctionsIDcause-List.h"
55 /*******************************************************************
57 * @brief Fill E2 Failure Cause
61 * Function : fillE2Cause
63 * Functionality: Fill E2 Failure Cause
65 * @params[in] E2 Cause pointer to be filled in
66 * E2 Cause to be filled from
69 ******************************************************************/
70 void fillE2Cause(CauseE2_t *e2Cause, E2FailureCause failureCause)
72 e2Cause->present = failureCause.causeType;
73 switch(e2Cause->present)
75 case CauseE2_PR_ricRequest:
77 e2Cause->choice.ricRequest = failureCause.cause;
80 case CauseE2_PR_ricService:
82 e2Cause->choice.ricService = failureCause.cause;
85 case CauseE2_PR_e2Node:
87 e2Cause->choice.e2Node = failureCause.cause;
90 case CauseE2_PR_transport:
92 e2Cause->choice.transport = failureCause.cause;
95 case CauseE2_PR_protocol:
97 e2Cause->choice.protocol = failureCause.cause;
100 case CauseE2_PR_misc:
102 e2Cause->choice.misc = failureCause.cause;
105 case CauseE2_PR_NOTHING:
111 /*******************************************************************
113 * @brief Builds Global gNodeB Params
117 * Function : BuildGlobalgNBId
119 * Functionality: Building the Plmn and gNB id
121 * @params[in] GlobalE2node_gNB_ID_t *gNbId
122 * @return ROK - success
125 ******************************************************************/
127 uint8_t BuildGlobalgNBId(GlobalE2node_gNB_ID_t *gNbId)
130 uint8_t byteSize = 4;
131 uint8_t gnbId = duCb.gnbId;
134 /* fill Global gNB ID Id */
135 gNbId->global_gNB_ID.plmn_id.size = 3 * sizeof(uint8_t);
136 gNbId->global_gNB_ID.plmn_id.buf = NULLP;
137 DU_ALLOC(gNbId->global_gNB_ID.plmn_id.buf , gNbId->global_gNB_ID.plmn_id.size);
138 if(gNbId->global_gNB_ID.plmn_id.buf == NULLP)
140 DU_LOG("\nERROR --> E2AP: Memory allocation failed for Plmn buffer");
145 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
146 gNbId->global_gNB_ID.plmn_id.buf);
147 gNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID;
148 /* Allocate Buffer size */
149 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size = byteSize * sizeof(uint8_t);
150 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf = NULLP;
151 DU_ALLOC(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf, \
152 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
153 if(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf == NULLP)
155 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gnb buffer");
160 fillBitString(&gNbId->global_gNB_ID.gnb_id.choice.gnb_ID, unused, byteSize, gnbId);
165 DU_ALLOC( gNbId->gNB_DU_ID, sizeof(GNB_DU_ID_t));
166 if(gNbId->gNB_DU_ID == NULLP)
168 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gNB_DU_ID ");
173 gNbId->gNB_DU_ID->size = sizeof(uint8_t);
174 DU_ALLOC( gNbId->gNB_DU_ID->buf, sizeof(uint8_t));
175 if(gNbId->gNB_DU_ID->buf)
177 gNbId->gNB_DU_ID->buf[0] =duCb.e2apDb.e2NodeId;
181 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gNB_DU_ID buffer");
189 /******************************************************************
191 * @brief Search E2 node component with the help of action type
195 * Function : searchE2NodeComponentInfo
197 * Functionality: Search E2 node component with the help of action type
199 * @params[in] uint8_t componentActionType
202 * ****************************************************************/
204 CmLList *searchE2NodeComponentInfo(InterfaceType interfaceType, uint8_t componentActionType)
206 E2NodeComponent *e2NodeComponentInfo;
209 if(duCb.e2apDb.e2NodeComponentList.count)
211 CM_LLIST_FIRST_NODE(&duCb.e2apDb.e2NodeComponentList, node);
214 e2NodeComponentInfo = (E2NodeComponent*)node->node;
215 if((e2NodeComponentInfo->interfaceType == interfaceType) && (e2NodeComponentInfo->componentActionType == componentActionType))
224 /*******************************************************************
226 * @brief Builds E2 node config addition list
230 * Function : BuildE2NodeConfigAddList
232 * Functionality: Building E2 node config addition list
234 * @params[in] E2nodeComponentConfigAddition_List_t *e2NodeAddList
235 * @return ROK - success
238 ******************************************************************/
240 uint8_t BuildE2NodeConfigAddList(E2nodeComponentConfigAddition_List_t *e2NodeAddList)
244 E2NodeComponent *e2NodeComponentInfo;
245 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItemIe;
246 E2nodeComponentConfigAddition_Item_t *e2NodeAddItem;
248 e2NodeAddList->list.count = 1;
249 e2NodeAddList->list.size = e2NodeAddList->list.count * sizeof(E2nodeComponentConfigAddition_ItemIEs_t *);
250 DU_ALLOC(e2NodeAddList->list.array, e2NodeAddList->list.size);
251 if(e2NodeAddList->list.array == NULLP)
253 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
257 for(arrIdx = 0; arrIdx< e2NodeAddList->list.count; arrIdx++)
259 DU_ALLOC(e2NodeAddList->list.array[arrIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
260 if(e2NodeAddList->list.array[arrIdx] == NULLP)
262 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
267 node = searchE2NodeComponentInfo(F1, E2_NODE_COMPONENT_ADD);
270 DU_LOG("\nERROR --> E2AP : Received e2NodeComponentInfo is null");
273 e2NodeComponentInfo = (E2NodeComponent*)node->node;
276 e2NodeAddItemIe = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[arrIdx];
277 e2NodeAddItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition_Item;
278 e2NodeAddItemIe->criticality = CriticalityE2_reject;
279 e2NodeAddItemIe->value.present = E2nodeComponentConfigAddition_ItemIEs__value_PR_E2nodeComponentConfigAddition_Item;
280 e2NodeAddItem = &e2NodeAddItemIe->value.choice.E2nodeComponentConfigAddition_Item;
282 /* E2nodeComponentInterfaceType */
283 e2NodeAddItem->e2nodeComponentInterfaceType = E2nodeComponentInterfaceType_f1;
285 /* E2 Node Component Request Part */
286 if(e2NodeComponentInfo->componentRequestPart)
288 e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.size = e2NodeComponentInfo->reqBufSize ;
289 DU_ALLOC(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf,\
290 e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.size);
291 if(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf == NULLP)
293 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
297 memcpy(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf,\
298 e2NodeComponentInfo->componentRequestPart, e2NodeAddItem->e2nodeComponentConfiguration.\
299 e2nodeComponentRequestPart.size);
303 DU_LOG("\nERROR --> E2AP: componentRequestPart is null ");
308 /* E2 Node Component Response Part */
309 if(e2NodeComponentInfo->componentResponsePart)
311 e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.size = e2NodeComponentInfo->rspBufSize;
312 DU_ALLOC(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.buf, \
313 e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.size);
314 if(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.buf == NULLP)
316 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
319 memcpy(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.buf, \
320 e2NodeComponentInfo->componentResponsePart, e2NodeAddItem->e2nodeComponentConfiguration.\
321 e2nodeComponentResponsePart.size);
325 DU_LOG("\nERROR --> E2AP: componentResponsePart is null");
329 /* E2 Node Component ID */
330 e2NodeAddItem->e2nodeComponentID.present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
331 DU_ALLOC(e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
332 sizeof(E2nodeComponentInterfaceF1_t));
333 if(e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1 == NULLP)
335 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
338 e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
339 DU_ALLOC(e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
340 e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
342 if(e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
344 DU_LOG("\nERROR -->list. E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
347 e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[arrIdx] = e2NodeComponentInfo->componentId;
352 /*******************************************************************
354 * @brief deallocation of E2SM_KPM_RANfunction_Description_t
358 * Function : freeE2smKpmRanFunctionDefinition
360 * Functionality: deallocation of E2SM_KPM_RANfunction_Description_t
362 * @params[in] E2SM_KPM_RANfunction_Description_t *ranFunctionDefinition
365 ******************************************************************/
367 void freeE2smKpmRanFunctionDefinition(E2SM_KPM_RANfunction_Description_t *ranFunctionDefinition)
369 MeasurementInfo_Action_Item_t *measInfoList;
370 uint8_t eventTriggerIdx, reportStyleIdx, measInfoIdx;
371 RANfunction_Name_t *ranFuncName;
372 struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle;
373 struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List *eventTriggerStyle;
374 if(ranFunctionDefinition)
376 ranFuncName = &ranFunctionDefinition->ranFunction_Name;
377 /* Free RAN function Name */
378 DU_FREE(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size);
379 DU_FREE(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size);
380 DU_FREE(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size);
382 /* Sequence of Event Trigger styles */
383 eventTriggerStyle = ranFunctionDefinition->ric_EventTriggerStyle_List;
384 if(eventTriggerStyle)
386 if(eventTriggerStyle->list.array)
388 for(eventTriggerIdx =0;eventTriggerIdx<eventTriggerStyle->list.count; eventTriggerIdx++)
390 if(eventTriggerStyle->list.array[eventTriggerIdx])
392 DU_FREE(eventTriggerStyle->list.array[eventTriggerIdx]->ric_EventTriggerStyle_Name.buf,\
393 eventTriggerStyle->list.array[eventTriggerIdx]->ric_EventTriggerStyle_Name.size);
394 DU_FREE(eventTriggerStyle->list.array[eventTriggerIdx], sizeof(RIC_EventTriggerStyle_Item_t ));
397 DU_FREE(eventTriggerStyle->list.array, eventTriggerStyle->list.size)
399 DU_FREE(eventTriggerStyle, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List));
402 /* Sequence of Report styles */
403 ricReportStyle = ranFunctionDefinition->ric_ReportStyle_List;
406 if(ricReportStyle->list.array)
408 for(reportStyleIdx =0;reportStyleIdx<ricReportStyle->list.count; reportStyleIdx++)
410 if(ricReportStyle->list.array[reportStyleIdx])
412 if(ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.buf)
414 DU_FREE(ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.buf,\
415 ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.size);
417 if(ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.array)
419 for(measInfoIdx=0; measInfoIdx<ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.count; \
422 measInfoList = ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.array[measInfoIdx];
425 DU_FREE(measInfoList->measID, sizeof(long));
426 DU_FREE(measInfoList->measName.buf, measInfoList->measName.size);
427 DU_FREE(measInfoList,sizeof(MeasurementInfo_Action_Item_t));
430 DU_FREE(measInfoList,ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.size);
432 DU_FREE(ricReportStyle->list.array[reportStyleIdx], sizeof(RIC_ReportStyle_Item_t));
435 DU_FREE(ricReportStyle->list.array, ricReportStyle->list.size);
437 DU_FREE(ricReportStyle, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List));
439 DU_FREE(ranFunctionDefinition, sizeof(E2SM_KPM_RANfunction_Description_t));
443 /*******************************************************************
445 * @brief fill the e2sm ric report style
449 * Function : fillRicReportStyle
451 * Functionality: fill the report style
453 * @params[in] RanFunction *ranFuncDb, struct
454 * E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle
455 * @return ROK - success
458 ******************************************************************/
459 uint8_t fillRicReportStyle(RanFunction *ranFuncDb, struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle)
461 uint8_t styleIdx, measInfoIdx;
462 MeasurementInfo_Action_List_t *measInfo;
465 ricReportStyle->list.count = ranFuncDb->numOfReportStyleSupported;
466 ricReportStyle->list.size = ricReportStyle->list.count * sizeof(RIC_ReportStyle_Item_t*);
467 DU_ALLOC(ricReportStyle->list.array, ricReportStyle->list.size);
468 if(!ricReportStyle->list.array)
470 DU_LOG("\nERROR --> E2AP: Memory allocation failed for ranFuncDefinition %d",__LINE__);
474 for(styleIdx =0;styleIdx<ricReportStyle->list.count; styleIdx++)
476 DU_ALLOC(ricReportStyle->list.array[styleIdx], sizeof(RIC_ReportStyle_Item_t));
477 if(!ricReportStyle->list.array[styleIdx])
479 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
483 /* RIC Report Style Type */
484 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Type = ranFuncDb->reportStyleList[styleIdx].reportStyle.styleType;
486 /* RIC Report Style Format Type */
487 ricReportStyle->list.array[styleIdx]->ric_ActionFormat_Type = ranFuncDb->reportStyleList[styleIdx].reportStyle.formatType;
489 /* RIC Report Style Name */
490 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size = strlen(ranFuncDb->reportStyleList[styleIdx].reportStyle.name);
491 DU_ALLOC(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf,\
492 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size);
493 if(!ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf)
495 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
498 memcpy(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf, ranFuncDb->reportStyleList[styleIdx].reportStyle.name,\
499 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size);
501 /* RIC Indication Header Format Type*/
502 ricReportStyle->list.array[styleIdx]->ric_IndicationHeaderFormat_Type = ranFuncDb->ricIndicationHeaderFormat;
504 /* RIC Indication Message Format Type*/
505 ricReportStyle->list.array[styleIdx]->ric_IndicationMessageFormat_Type = ranFuncDb->ricIndicationMessageFormat;
507 /* Measurement Info Action List */
508 CmLListCp measInfoList =ranFuncDb->reportStyleList[styleIdx].measurementInfoList;
509 if(!measInfoList.count)
514 CM_LLIST_FIRST_NODE(&ranFuncDb->reportStyleList[styleIdx].measurementInfoList, node);
515 measInfo = &ricReportStyle->list.array[styleIdx]->measInfo_Action_List;
517 measInfo->list.count = measInfoList.count;
518 measInfo->list.size = measInfoList.count*sizeof(MeasurementInfo_Action_Item_t*);
519 DU_ALLOC(measInfo->list.array, measInfo->list.size);
520 if(!measInfo->list.array)
522 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
526 for(measInfoIdx=0; measInfoIdx<measInfo->list.count; measInfoIdx++)
530 DU_LOG("\nERROR --> E2AP: Measurement info node is null");
534 DU_ALLOC(measInfo->list.array[measInfoIdx],sizeof(MeasurementInfo_Action_Item_t));
535 if(!measInfo->list.array[measInfoIdx])
537 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
540 MeasurementInfoForAction *measInfoForAction= (MeasurementInfoForAction*)node->node;
541 DU_ALLOC(measInfo->list.array[measInfoIdx]->measID, sizeof(long));
542 if(!measInfo->list.array[measInfoIdx]->measID)
544 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
548 memcpy(measInfo->list.array[measInfoIdx]->measID, &measInfoForAction->measurementTypeId,sizeof(long));
549 measInfo->list.array[measInfoIdx]->measName.size= strlen(measInfoForAction->measurementTypeName);
550 DU_ALLOC(measInfo->list.array[measInfoIdx]->measName.buf, measInfo->list.array[measInfoIdx]->measName.size);
551 if(!measInfo->list.array[measInfoIdx]->measName.size)
553 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
557 memcpy(measInfo->list.array[measInfoIdx]->measName.buf, \
558 measInfoForAction->measurementTypeName,\
559 measInfo->list.array[measInfoIdx]->measName.size);
566 /*******************************************************************
568 * @brief fill the ric event trigger style
572 * Function : fillRicEventTriggerStyle
574 * Functionality: fill the ric event trigger style
577 * @return ROK - success
580 ******************************************************************/
581 uint8_t fillRicEventTriggerStyle(RanFunction *ranFuncDb, struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List *ricEventTriggerStyle)
585 ricEventTriggerStyle->list.count = ranFuncDb->numOfEventTriggerStyleSupported;
586 ricEventTriggerStyle->list.size = ricEventTriggerStyle->list.count* sizeof(RIC_EventTriggerStyle_Item_t *);
587 DU_ALLOC(ricEventTriggerStyle->list.array, ricEventTriggerStyle->list.size);
588 if(!ricEventTriggerStyle->list.array)
590 DU_LOG("\nERROR --> E2AP: Memory allocation failed for ric_EventTriggerStyle_List %d",__LINE__);
594 for(styleIdx =0;styleIdx<ricEventTriggerStyle->list.count; styleIdx++)
596 DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx], sizeof(RIC_EventTriggerStyle_Item_t ));
597 if(!ricEventTriggerStyle->list.array[styleIdx])
599 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
602 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Type = ranFuncDb->eventTriggerStyleList[styleIdx].styleType;
604 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerFormat_Type = ranFuncDb->eventTriggerStyleList[styleIdx].formatType;
606 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size = strlen(ranFuncDb->eventTriggerStyleList[styleIdx].name);
607 DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,\
608 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size);
609 if(!ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf)
611 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
614 memcpy(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,ranFuncDb->eventTriggerStyleList[styleIdx].name,\
615 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size);
621 /*******************************************************************
623 * @brief Builds Ran function item
627 * Function : BuildRanFunctionItem
629 * Functionality: Building RAN function item
632 * RAN function item that has to be filled
633 * Stored RAN Function information
634 * @return ROK - success
637 ******************************************************************/
639 uint8_t BuildRanFunctionItem(RANfunction_Item_t *ranFuncItem, RanFunction *ranFuncDb)
641 uint8_t ret =RFAILED;
642 RANfunctionDefinition_t *ranFunctionDefinition;
643 RANfunction_Name_t *ranFuncName;
644 asn_enc_rval_t encRetVal;
645 E2SM_KPM_RANfunction_Description_t *ranFuncDefinition;
650 ranFuncItem->ranFunctionID = ranFuncDb->id;
652 /* RAN Function Revision*/
653 ranFuncItem->ranFunctionRevision = ranFuncDb->revisionCounter;
655 /* RAN function OID*/
656 ranFuncItem->ranFunctionOID.size = strlen(ranFuncDb->name.serviceModelOID);
657 DU_ALLOC(ranFuncItem->ranFunctionOID.buf, ranFuncItem->ranFunctionOID.size);
658 if(!ranFuncItem->ranFunctionOID.buf)
660 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
663 memcpy(ranFuncItem->ranFunctionOID.buf, ranFuncDb->name.serviceModelOID, ranFuncItem->ranFunctionOID.size);
665 /* RAN function Definition */
666 DU_ALLOC(ranFuncDefinition, sizeof(E2SM_KPM_RANfunction_Description_t));
667 if(!ranFuncDefinition)
669 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
673 /* RAN function Name */
674 ranFuncName = &ranFuncDefinition->ranFunction_Name;
676 /* RAN function ShortName */
677 ranFuncName->ranFunction_ShortName.size = strlen(ranFuncDb->name.shortName);
678 DU_ALLOC(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size);
679 if(!ranFuncName->ranFunction_ShortName.buf)
681 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
684 memcpy(ranFuncName->ranFunction_ShortName.buf, ranFuncDb->name.shortName, strlen(ranFuncDb->name.shortName));
686 /* RAN function E2SM_OID */
687 ranFuncName->ranFunction_E2SM_OID.size = strlen(ranFuncDb->name.serviceModelOID);
688 DU_ALLOC(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size);
689 if(!ranFuncName->ranFunction_E2SM_OID.buf)
691 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
694 memcpy(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncDb->name.serviceModelOID, ranFuncName->ranFunction_E2SM_OID.size);
696 /* RAN Function Name Description */
697 ranFuncName->ranFunction_Description.size = strlen(ranFuncDb->name.description);
698 DU_ALLOC(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size);
699 if(!ranFuncName->ranFunction_Description.buf)
701 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
704 memcpy(ranFuncName->ranFunction_Description.buf, ranFuncDb->name.description, ranFuncName->ranFunction_Description.size);
706 /* RIC Event Trigger Style List */
707 DU_ALLOC(ranFuncDefinition->ric_EventTriggerStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List));
708 if(!ranFuncDefinition->ric_EventTriggerStyle_List)
710 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
714 if(fillRicEventTriggerStyle(ranFuncDb, ranFuncDefinition->ric_EventTriggerStyle_List)!=ROK)
716 DU_LOG("\nERROR --> E2AP: failed to fill ric event trigger style");
720 /* RIC Report Style List */
721 DU_ALLOC(ranFuncDefinition->ric_ReportStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List));
722 if(!ranFuncDefinition->ric_ReportStyle_List)
724 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
727 if(fillRicReportStyle(ranFuncDb, ranFuncDefinition->ric_ReportStyle_List) != ROK)
729 DU_LOG("\nERROR --> E2AP: failed to fill ric report style");
733 /* Encode the F1SetupRequest type as APER */
734 xer_fprint(stdout, &asn_DEF_E2SM_KPM_RANfunction_Description, ranFuncDefinition);
736 memset(encBuf, 0, ENC_BUF_MAX_LEN);
738 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_RANfunction_Description, 0, ranFuncDefinition, PrepFinalEncBuf, encBuf);
741 if(encRetVal.encoded == ENCODE_FAIL)
743 DU_LOG("\nERROR --> F1AP : Could not encode RAN function definition (at %s)\n",\
744 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
749 DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RAN function definition \n");
750 for(uint8_t measIeIdx=0; measIeIdx< encBufSize; measIeIdx++)
752 printf("%x",encBuf[measIeIdx]);
754 ranFunctionDefinition = &ranFuncItem->ranFunctionDefinition;
755 ranFunctionDefinition->size = encBufSize;
756 DU_ALLOC(ranFunctionDefinition->buf, encBufSize);
757 if(ranFunctionDefinition->buf == NULLP)
759 DU_LOG("\nERROR --> F1AP : Memory allocation failed for RAN function definition buffer");
762 memcpy(ranFunctionDefinition->buf, &encBuf, encBufSize);
767 freeE2smKpmRanFunctionDefinition(ranFuncDefinition);
771 /*******************************************************************
773 * @brief Builds Ran function add list based on the procedure code
777 * Function : BuildRanFunctionAddList
779 * Functionality: Building RAN addition addition list
780 * In case of ProcedureCodeE2_id_E2setup we add all the RAN Function list
781 * which is present in E2 database.
782 * In the case of other procedures, we just fill the RAN functions whose ID
783 * is contained in recvList
788 * Count of ran functions to be added in the list
789 * Received list of RAN functions
791 * @return ROK - success
794 ******************************************************************/
796 uint8_t BuildRanFunctionAddList(RANfunctions_List_t *ranFunctionsList, uint8_t procedureCode, uint8_t count, RanFuncInfo *recvList)
799 RanFunction *ranFuncDb;
801 RANfunction_ItemIEs_t *ranFuncItemIe;
803 /* For ProcedureCodeE2_id_E2setup, the number of RAN function list items is
804 * equal to the number of ran function entries stored in the database.
805 * For any other procedure, the RAN function list count is equal
806 * to the count of ran functions obtained from the function's caller */
808 if(procedureCode == ProcedureCodeE2_id_E2setup)
809 ranFunctionsList->list.count = duCb.e2apDb.numOfRanFunction;
811 ranFunctionsList->list.count = count;
813 ranFunctionsList->list.size = ranFunctionsList->list.count * sizeof(RANfunction_ItemIEs_t*);
814 DU_ALLOC(ranFunctionsList->list.array, ranFunctionsList->list.size);
815 if(ranFunctionsList->list.array == NULLP)
817 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
821 for(ranFuncIdx = 0; ranFuncIdx< ranFunctionsList->list.count; ranFuncIdx++)
823 DU_ALLOC(ranFunctionsList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
824 if(ranFunctionsList->list.array[ranFuncIdx] == NULLP)
826 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
829 if(procedureCode == ProcedureCodeE2_id_E2setup)
831 /* Getting all of the RAN function's information from DuCb one by one*/
832 ranFuncDb = &duCb.e2apDb.ranFunction[ranFuncIdx];
836 /* Getting only the RAN function information from DuCb whose Id is
837 * present in the received array */
838 id =recvList[ranFuncIdx].id;
839 ranFuncDb = &duCb.e2apDb.ranFunction[id-1];
841 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
842 ranFuncItemIe->id = ProtocolIE_IDE2_id_RANfunction_Item;
843 ranFuncItemIe->criticality = CriticalityE2_ignore;
844 ranFuncItemIe->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item;
845 BuildRanFunctionItem(&ranFuncItemIe->value.choice.RANfunction_Item, ranFuncDb);
850 /*******************************************************************
852 * @brief De Allocate E2 Setup Request Message
856 * Function : FreeE2SetupReq
858 * Functionality: De-Allocating E2 Setup request Message
860 * @params[in] E2AP_PDU_t *e2apMsg
864 * ****************************************************************/
866 void FreeE2SetupReq(E2AP_PDU_t *e2apMsg)
869 uint8_t e2NodeAddListIdx =0, ranFuncAddListIdx;
870 E2setupRequest_t *e2SetupReq;
871 E2nodeComponentConfigAddition_List_t *e2NodeAddList;
872 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem;
873 RANfunctions_List_t *ranFunctionsList;
874 RANfunction_ItemIEs_t *ranFuncItemIe;
875 RANfunction_Item_t *ranFunItem;
877 /* De-allocating Memory */
880 if(e2apMsg->choice.initiatingMessage != NULLP)
882 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
883 if(e2SetupReq->protocolIEs.list.array != NULLP)
885 for(arrIdx = 0; arrIdx < e2SetupReq->protocolIEs.list.count; arrIdx++)
887 if(e2SetupReq->protocolIEs.list.array[arrIdx] != NULLP)
889 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
891 case ProtocolIE_IDE2_id_TransactionID:
893 case ProtocolIE_IDE2_id_GlobalE2node_ID:
895 if(e2SetupReq->protocolIEs.list.array[arrIdx]->\
896 value.choice.GlobalE2node_ID.choice.gNB != NULLP)
898 GlobalE2node_gNB_ID_t *gNbId = NULLP;
899 gNbId = e2SetupReq->protocolIEs.list.array[arrIdx]->\
900 value.choice.GlobalE2node_ID.choice.gNB;
901 if(gNbId->global_gNB_ID.plmn_id.buf != NULLP)
903 DU_FREE(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf,\
904 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
905 DU_FREE(gNbId->global_gNB_ID.plmn_id.buf,\
906 gNbId->global_gNB_ID.plmn_id.size);
909 if(gNbId->gNB_DU_ID != NULLP)
911 DU_FREE( gNbId->gNB_DU_ID->buf, gNbId->gNB_DU_ID->size);
912 DU_FREE(gNbId->gNB_DU_ID, sizeof(GNB_DU_ID_t));
914 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
915 choice.GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
919 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
921 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
922 if(e2NodeAddList->list.array)
924 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
926 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
928 /* Free E2 Node Component Request Part */
929 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf,\
930 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.size);
932 /* Free E2 Node Component Response Part */
933 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.\
934 e2nodeComponentResponsePart.buf, \
935 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentResponsePart.size);
937 /* Free E2 Node Component ID */
938 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1)
940 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
941 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
942 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
943 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
944 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
945 sizeof(E2nodeComponentInterfaceF1_t));
947 DU_FREE(e2NodeAddList->list.array[e2NodeAddListIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
949 DU_FREE(e2NodeAddList->list.array, e2NodeAddList->list.size);
953 case ProtocolIE_IDE2_id_RANfunctionsAdded:
955 ranFunctionsList = &(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List);
956 if(ranFunctionsList->list.array)
958 for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++)
960 if(ranFunctionsList->list.array[ranFuncAddListIdx])
962 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx];
963 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
964 DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size);
965 DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size);
966 DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t));
969 DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size);
975 DU_LOG("\nERROR --> E2AP: Invalid event at e2SetupRequet %ld ",\
976 (e2SetupReq->protocolIEs.list.array[arrIdx]->id));
979 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx], sizeof(E2setupRequestIEs_t));
982 DU_FREE(e2SetupReq->protocolIEs.list.array, e2SetupReq->protocolIEs.list.size);
984 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
986 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
990 /*******************************************************************
992 * @brief Builds and Send the E2SetupRequest
996 * Function : BuildAndSendE2SetupReq
998 * Functionality:Fills the E2SetupRequest
1000 * @return ROK - success
1003 ******************************************************************/
1005 uint8_t BuildAndSendE2SetupReq()
1007 uint8_t arrIdx = 0, elementCnt=0;
1008 uint8_t transId = 0, ret = ROK;
1009 bool memAllocFailed;
1010 E2AP_PDU_t *e2apMsg = NULLP;
1011 E2setupRequest_t *e2SetupReq = NULLP;
1012 asn_enc_rval_t encRetVal; /* Encoder return value */
1014 DU_LOG("\nINFO --> E2AP : Building E2 Setup Request\n");
1017 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1018 if(e2apMsg == NULLP)
1020 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1023 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
1024 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1025 if(e2apMsg->choice.initiatingMessage == NULLP)
1027 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1030 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
1031 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2setup;
1032 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2setupRequest;
1033 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
1036 e2SetupReq->protocolIEs.list.count = elementCnt;
1037 e2SetupReq->protocolIEs.list.size = elementCnt * sizeof(E2setupRequestIEs_t*);
1039 /* Initialize the E2Setup members */
1040 DU_ALLOC(e2SetupReq->protocolIEs.list.array, \
1041 e2SetupReq->protocolIEs.list.size);
1042 if(e2SetupReq->protocolIEs.list.array == NULLP)
1044 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
1047 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
1049 DU_ALLOC(e2SetupReq->protocolIEs.list.array[arrIdx],\
1050 sizeof(E2setupRequestIEs_t));
1051 if(e2SetupReq->protocolIEs.list.array[arrIdx] == NULLP)
1053 memAllocFailed = true;
1054 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayarrIdx [%d]", arrIdx);
1058 if(memAllocFailed == true)
1064 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1065 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1066 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
1067 transId = assignTransactionId();
1068 e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
1071 /* GlobalE2node_gNB_ID */
1072 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_GlobalE2node_ID;
1073 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1074 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID;
1075 e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB;
1077 DU_ALLOC(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
1078 GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
1079 if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
1080 GlobalE2node_ID.choice.gNB == NULLP)
1082 DU_LOG("\nERROR --> E2AP : Memory allocation failed for gNbId");
1087 ret = BuildGlobalgNBId(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
1088 choice.GlobalE2node_ID.choice.gNB);
1091 DU_LOG("\nERROR --> E2AP : Failed to build Global Gnb Id");
1096 /* RAN Functions Added List */
1098 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded;
1099 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1100 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_RANfunctions_List;
1101 if(BuildRanFunctionAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List), ProcedureCodeE2_id_E2setup, 0, NULL)!=ROK)
1103 DU_LOG("\nERROR --> E2AP : Failed to create RAN Function");
1107 /* E2 Node Component Configuration Addition List */
1109 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition;
1110 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1111 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_E2nodeComponentConfigAddition_List;
1112 if(BuildE2NodeConfigAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List))!=ROK)
1114 DU_LOG("\nERROR --> E2AP : Failed to create E2 Node config list");
1120 /* Prints the Msg formed */
1121 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1123 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1125 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1127 if(encRetVal.encoded == ENCODE_FAIL)
1129 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\
1130 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1135 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n");
1136 #ifdef DEBUG_ASN_PRINT
1137 for(int i=0; i< encBufSize; i++)
1139 printf("%x",encBuf[i]);
1143 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
1145 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
1150 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
1151 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
1153 FreeE2SetupReq(e2apMsg);
1155 }/* End of BuildAndSendE2SetupReq */
1157 /*******************************************************************
1159 * @brief Builds Ric Request Id
1163 * Function : BuildRicRequestId
1165 * Functionality: Building the Ric Request Id
1167 * @params[in] RICrequestID_t *ricReqId
1168 * @return ROK - success
1171 * ****************************************************************/
1173 uint8_t BuildRicRequestId(RICrequestID_t *ricReqId)
1175 if(ricReqId == NULLP)
1180 ricReqId->ricRequestorID = 1;
1181 ricReqId->ricInstanceID = 1;
1185 /*******************************************************************
1187 * @brief Fills the mandatory RicAdmitted List Items
1191 * Function : fillRicAdmitList
1193 * Functionality: Fills the mandatory Ric Admitted List Items
1195 * @params[in] RICaction_Admitted_ItemIEs_t *ricAdmitItems
1196 * @return ROK - success
1199 * ****************************************************************/
1201 uint8_t fillRicAdmitList(RICaction_Admitted_ItemIEs_t *ricAdmitItems)
1204 if(ricAdmitItems != NULLP)
1206 ricAdmitItems->id = ProtocolIE_IDE2_id_RICaction_Admitted_Item;
1207 ricAdmitItems->criticality = CriticalityE2_reject;
1208 ricAdmitItems->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
1209 ricAdmitItems->value.choice.RICaction_Admitted_Item.ricActionID = 1;
1217 /*******************************************************************
1219 * @brief Builds the mandatory RicAdmitted List Params
1223 * Function : BuildRicAdmitList
1225 * Functionality: Builds the mandatory Ric Admitted List Params
1227 * @params[in] RICaction_Admitted_List_t *admitListPtr
1228 * @return ROK - success
1231 * ****************************************************************/
1233 uint8_t BuildRicAdmitList(RICaction_Admitted_List_t *admitListPtr)
1240 if(admitListPtr == NULLP)
1242 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC Admit List failed");
1247 admitListPtr->list.count = elementCnt;
1248 admitListPtr->list.size = elementCnt * sizeof(RICaction_Admitted_ItemIEs_t);
1249 DU_ALLOC(admitListPtr->list.array, admitListPtr->list.size);
1250 if(admitListPtr->list.array == NULLP)
1252 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC Admit List failed");
1257 for(idx=0 ; idx<elementCnt ; idx++ )
1259 DU_ALLOC(admitListPtr->list.array[idx], sizeof(RICaction_Admitted_ItemIEs_t));
1260 if(admitListPtr->list.array[idx] == NULLP)
1268 fillRicAdmitList((RICaction_Admitted_ItemIEs_t *)admitListPtr->list.array[idx]);
1274 /*******************************************************************
1276 * @breif Deallocation of BuildAndSendRicSubscriptionRsp memory
1280 * Function : FreeRicSubscriptionRsp
1282 * Functionality:Free the RicSubscriptionRsp
1284 * @param[in] E2AP_PDU_t *e2apRicMsg
1289 ******************************************************************/
1290 void FreeRicSubscriptionRsp(E2AP_PDU_t *e2apRicMsg)
1292 RICsubscriptionResponse_t *ricSubscriptionRsp= NULLP;
1295 RICaction_Admitted_List_t *admitListPtr;
1297 if(e2apRicMsg != NULLP)
1299 if(e2apRicMsg->choice.successfulOutcome != NULLP)
1301 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
1302 if(ricSubscriptionRsp)
1304 if(ricSubscriptionRsp->protocolIEs.list.array != NULLP)
1306 for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
1308 if(ricSubscriptionRsp->protocolIEs.list.array[idx] != NULLP)
1310 switch(ricSubscriptionRsp->protocolIEs.list.array[idx]->id)
1312 case ProtocolIE_IDE2_id_RICrequestID:
1315 case ProtocolIE_IDE2_id_RANfunctionID:
1318 case ProtocolIE_IDE2_id_RICactions_Admitted:
1320 admitListPtr = &ricSubscriptionRsp->protocolIEs.list.\
1321 array[idx]->value.choice.RICaction_Admitted_List;
1322 if(admitListPtr->list.array != NULLP)
1324 for(idx1=0 ; idx1<admitListPtr->list.count; idx1++ )
1326 if(admitListPtr->list.array[idx1] != NULLP)
1328 DU_FREE(admitListPtr->list.array[idx1],
1329 sizeof(RICaction_Admitted_ItemIEs_t));
1332 DU_FREE(admitListPtr->list.array, admitListPtr->list.size);
1339 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array[idx], \
1340 sizeof(RICsubscriptionResponse_IEs_t));
1343 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array, \
1344 ricSubscriptionRsp->protocolIEs.list.size);
1347 DU_FREE(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1349 DU_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
1352 /*******************************************************************
1354 * @brief Builds and Send the RicSubscriptionRsp
1358 * Function : BuildAndSendRicSubscriptionRsp
1360 * functionality:Fills the RicSubscriptionRsp
1362 * @return ROK - success
1365 ******************************************************************/
1366 uint8_t FillRicSubscriptionRsp(RICsubscriptionResponse_t *ricSubscriptionRsp )
1370 uint8_t elementCnt = 0;
1371 uint8_t BuildRicRequestIdret=ROK;
1372 uint8_t BuildRicAdmitListret=ROK;
1375 ricSubscriptionRsp->protocolIEs.list.count = elementCnt;
1376 ricSubscriptionRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionResponse_IEs_t);
1377 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array, \
1378 ricSubscriptionRsp->protocolIEs.list.size);
1379 if(ricSubscriptionRsp->protocolIEs.list.array == NULLP)
1381 DU_LOG("\nERROR --> E2AP : Memory allocation for FillRicSubscriptionRsp failed");
1386 for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
1388 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array[idx], \
1389 sizeof(RICsubscriptionResponse_IEs_t));
1390 if(ricSubscriptionRsp->protocolIEs.list.array[idx] == NULLP)
1399 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
1400 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1401 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
1402 RICsubscriptionRequest_IEs__value_PR_RICrequestID;
1403 BuildRicRequestIdret =
1404 BuildRicRequestId(&ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RICrequestID);
1405 if(BuildRicRequestIdret != ROK)
1412 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
1413 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1414 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
1415 RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
1416 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionID = 1;
1419 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactions_Admitted;
1420 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1421 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
1422 RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
1423 BuildRicAdmitListret =
1424 BuildRicAdmitList(&ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RICaction_Admitted_List);
1425 if(BuildRicAdmitListret != ROK)
1434 /*******************************************************************
1436 * @brief Builds and Send the RicSubscriptionRsp
1440 * Function : BuildAndSendRicSubscriptionRsp
1442 * Functionality:Fills the RicSubscriptionRsp
1444 * @return ROK - success
1447 ******************************************************************/
1449 uint8_t BuildAndSendRicSubscriptionRsp()
1452 E2AP_PDU_t *e2apRicMsg = NULLP;
1453 RICsubscriptionResponse_t *ricSubscriptionRsp=NULLP;
1454 asn_enc_rval_t encRetVal;
1455 uint8_t ret = RFAILED;
1456 uint8_t FillRicricSubscriptionRspret;
1460 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Response\n");
1462 DU_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
1463 if(e2apRicMsg == NULLP)
1465 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1468 e2apRicMsg->present = E2AP_PDU_PR_successfulOutcome;
1469 DU_ALLOC(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1470 if(e2apRicMsg->choice.successfulOutcome == NULLP)
1472 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC subscription Response failed");
1476 e2apRicMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
1477 e2apRicMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
1478 e2apRicMsg->choice.successfulOutcome->value.present = \
1479 SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse;
1480 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
1482 FillRicricSubscriptionRspret = FillRicSubscriptionRsp(ricSubscriptionRsp);
1483 if(FillRicricSubscriptionRspret != ROK)
1485 DU_LOG("\nERROR --> E2AP : Memory allocation for RICsubscriptionResponseIE failed");
1489 /* Prints the Msg formed */
1490 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
1492 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1494 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf,\
1496 if(encRetVal.encoded == ENCODE_FAIL)
1498 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
1499 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1504 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription response \n");
1505 #ifdef DEBUG_ASN_PRINT
1506 for(int i=0; i< encBufSize; i++)
1508 printf("%x",encBuf[i]);
1513 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
1515 DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Response failed");
1523 FreeRicSubscriptionRsp(e2apRicMsg);
1528 /******************************************************************
1530 * @brief Deallocation of memory allocated bu aper decoder for e2 setup response
1534 * Function : freeAperDecodingOfE2SetupRsp
1536 * Functionality: Deallocation of memory allocated bu aper decoder for e2
1539 * @params[in] E2setupResponse_t *e2SetRspMsg;
1542 * ****************************************************************/
1543 void freeAperDecodingOfE2SetupRsp(E2setupResponse_t *e2SetRspMsg)
1545 uint8_t arrIdx, e2NodeConfigAddAckListIdx;
1546 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem;
1547 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAddAckList;
1551 if(e2SetRspMsg->protocolIEs.list.array)
1553 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
1555 if(e2SetRspMsg->protocolIEs.list.array[arrIdx])
1557 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
1559 case ProtocolIE_IDE2_id_TransactionID:
1562 case ProtocolIE_IDE2_id_GlobalRIC_ID:
1564 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.pLMN_Identity.buf);
1565 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID.buf);
1569 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
1571 e2NodeConfigAddAckList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
1572 if(e2NodeConfigAddAckList->list.array )
1574 for(e2NodeConfigAddAckListIdx = 0; e2NodeConfigAddAckListIdx< e2NodeConfigAddAckList->list.count; e2NodeConfigAddAckListIdx++)
1576 if(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx])
1578 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx];
1579 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
1580 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf);
1581 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
1582 e2nodeComponentInterfaceTypeF1);
1583 free(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx]);
1586 free(e2NodeConfigAddAckList->list.array);
1591 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]);
1594 free(e2SetRspMsg->protocolIEs.list.array);
1598 /******************************************************************
1600 * @brief Processes E2 Setup Response sent by RIC
1604 * Function : procE2SetupRsp
1606 * Functionality: Processes E2 Setup Response sent by RIC
1608 * @params[in] E2AP_PDU_t ASN decoded E2AP message
1609 * @return ROK - success
1612 * ****************************************************************/
1613 uint8_t procE2SetupRsp(E2AP_PDU_t *e2apMsg)
1615 uint8_t arrIdx =0, transId=0;
1616 uint32_t recvBufLen;
1617 E2setupResponse_t *e2SetRspMsg;
1619 E2NodeComponent *e2NodeComponentInfo;
1621 DU_LOG("\nINFO --> E2AP : E2 Setup Response received");
1622 duCb.e2Status = TRUE; //Set E2 status as true
1623 e2SetRspMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
1625 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
1627 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
1629 case ProtocolIE_IDE2_id_TransactionID:
1631 transId = e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
1632 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
1633 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
1635 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
1639 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
1645 case ProtocolIE_IDE2_id_GlobalRIC_ID:
1647 /* To store the Ric Id Params */
1648 recvBufLen = sizeof(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value\
1649 .choice.GlobalRIC_ID.pLMN_Identity.size);
1650 memcpy(&duCb.e2apDb.ricId.plmnId, e2SetRspMsg->protocolIEs.list.array[arrIdx]\
1651 ->value.choice.GlobalRIC_ID.pLMN_Identity.buf, recvBufLen);
1652 bitStringToInt(&e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID, &duCb.e2apDb.ricId);
1653 /*TODO : duCb.e2apDb.ricId.plmnId memory to be deallocated after the usage */
1657 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
1661 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2SetupRsp:%ld",
1662 e2SetRspMsg->protocolIEs.list.array[arrIdx]->id);
1666 freeAperDecodingOfE2SetupRsp(e2SetRspMsg);
1668 node = searchE2NodeComponentInfo(F1, E2_NODE_COMPONENT_ADD);
1671 DU_LOG("\nERROR --> E2AP : Received e2NodeComponentInfo is null");
1676 e2NodeComponentInfo = (E2NodeComponent*)node->node;
1677 cmLListDelFrm(&duCb.e2apDb.e2NodeComponentList, node);
1678 DU_FREE(e2NodeComponentInfo->componentRequestPart, e2NodeComponentInfo->reqBufSize);
1679 DU_FREE(e2NodeComponentInfo->componentResponsePart, e2NodeComponentInfo->rspBufSize);
1680 DU_FREE(e2NodeComponentInfo, sizeof(E2NodeComponent));
1681 DU_FREE(node, sizeof(CmLList));
1684 BuildAndSendE2NodeConfigUpdate();
1688 /*******************************************************************
1690 * @brief Free RIC Subscription Request
1694 * Function : freeAperDecodingOfRicSubsReq
1696 * Functionality : Free RIC Subscription Request
1700 ******************************************************************/
1701 void freeAperDecodingOfRicSubsReq(RICsubscriptionRequest_t *ricSubscriptionReq)
1704 uint8_t elementIdx = 0;
1705 RICsubscriptionDetails_t *subsDetails = NULLP;
1706 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
1708 if(ricSubscriptionReq->protocolIEs.list.array)
1710 for(idx=0; idx < ricSubscriptionReq->protocolIEs.list.count; idx++)
1712 switch(ricSubscriptionReq->protocolIEs.list.array[idx]->id)
1714 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
1716 subsDetails = &(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails);
1717 free(subsDetails->ricEventTriggerDefinition.buf);
1719 if(subsDetails->ricAction_ToBeSetup_List.list.array)
1721 for(elementIdx = 0; elementIdx < subsDetails->ricAction_ToBeSetup_List.list.count; elementIdx++)
1723 if(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
1725 actionItem = (RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.\
1726 list.array[elementIdx];
1727 if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
1729 free(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf);
1730 free(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition);
1732 free(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx]);
1735 free(subsDetails->ricAction_ToBeSetup_List.list.array);
1740 free(ricSubscriptionReq->protocolIEs.list.array[idx]);
1742 free(ricSubscriptionReq->protocolIEs.list.array);
1746 /*******************************************************************
1748 * @brief Free Event Trigger Definition
1752 * Function : freeAperDecodingOfEventTriggerDef
1754 * Functionality: Free Event Trigger Definition
1756 * @params[in] E2SM-KPM Event Trigger Definition
1759 * ****************************************************************/
1760 void freeAperDecodingOfEventTriggerDef(E2SM_KPM_EventTriggerDefinition_t *eventTiggerDef)
1764 switch(eventTiggerDef->eventDefinition_formats.present)
1766 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING:
1769 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1:
1770 free(eventTiggerDef->eventDefinition_formats.choice.eventDefinition_Format1);
1776 /*******************************************************************
1778 * @brief Extract E2SM-KPM Event trigger definition
1782 * Function : extractEventTriggerDef
1784 * Functionality : This function :
1785 * - Decodes E2SM-KPM Event Trigger Definition
1786 * - Validates that even trigger style is supported by E2 node
1787 * - Stores event trigger details in local DB
1789 * @params[in] RAN Function Database structure
1790 * RIC Subscription Info to be added to RAN function
1791 * RIC Event Trigger Definition buffer received from RIC
1792 * @return ROK - success
1795 ******************************************************************/
1796 uint8_t extractEventTriggerDef(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
1797 RICeventTriggerDefinition_t *ricEventTriggerDef, E2FailureCause *failureCause)
1799 uint8_t ret = RFAILED;
1800 uint8_t eventIdx = 0;
1801 asn_dec_rval_t rval ={0};
1802 E2SM_KPM_EventTriggerDefinition_t eventTiggerDef, *eventTiggerDefPtr = NULLP;
1804 /* Decoding E2SM-KPM Even Trigger Definition */
1805 eventTiggerDefPtr = &eventTiggerDef;
1806 memset(eventTiggerDefPtr, 0, sizeof(E2SM_KPM_EventTriggerDefinition_t));
1808 rval = aper_decode(0, &asn_DEF_E2SM_KPM_EventTriggerDefinition, (void **)&eventTiggerDefPtr, ricEventTriggerDef->buf,\
1809 ricEventTriggerDef->size, 0, 0);
1810 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
1812 DU_LOG("\nERROR --> E2AP : ASN decode failed for E2SM-KPM Event Trigger Definition");
1813 failureCause->causeType = E2_PROTOCOL;
1814 failureCause->cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
1818 xer_fprint(stdout, &asn_DEF_E2SM_KPM_EventTriggerDefinition, eventTiggerDefPtr);
1820 /* Validating the received event trigger definition format */
1821 for(eventIdx = 0; eventIdx < ranFuncDb->numOfEventTriggerStyleSupported; eventIdx++)
1823 if((eventTiggerDefPtr->eventDefinition_formats.present != \
1824 E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING) && \
1825 (eventTiggerDefPtr->eventDefinition_formats.present == ranFuncDb->eventTriggerStyleList[eventIdx].formatType))
1827 ricSubscriptionInfo->eventTriggerDefinition.formatType = ranFuncDb->eventTriggerStyleList[eventIdx].formatType;
1828 ricSubscriptionInfo->eventTriggerDefinition.choice.format1.reportingPeriod = \
1829 eventTiggerDefPtr->eventDefinition_formats.choice.eventDefinition_Format1->reportingPeriod;
1838 failureCause->causeType = E2_RIC_REQUEST;
1839 failureCause->cause = E2_EVENT_TRIGGER_NOT_SUPPORTED;
1841 /* Free E2SM_KPM_EventTriggerDefinition_t */
1842 freeAperDecodingOfEventTriggerDef(eventTiggerDefPtr);
1846 /*******************************************************************
1848 * @brief Free RIC Action Definition
1852 * Function : freeAperDecodingOfRicActionDefinition
1854 * Functionality: Free RIC Action Definition
1856 * @params[in] E2SM-KPM Action definition
1859 * ****************************************************************/
1860 void freeAperDecodingOfRicActionDefinition(E2SM_KPM_ActionDefinition_t *actionDef)
1862 uint8_t elementIdx = 0;
1863 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
1864 MeasurementInfoItem_t *measItem = NULLP;
1866 switch(actionDef->actionDefinition_formats.present)
1868 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
1870 if(actionDef->actionDefinition_formats.choice.actionDefinition_Format1)
1872 actionFormat1 = actionDef->actionDefinition_formats.choice.actionDefinition_Format1;
1873 if(actionFormat1->measInfoList.list.array)
1875 for(elementIdx = 0; elementIdx < actionFormat1->measInfoList.list.count; elementIdx++)
1877 if(actionFormat1->measInfoList.list.array[elementIdx])
1879 measItem = actionFormat1->measInfoList.list.array[elementIdx];
1880 switch(measItem->measType.present)
1882 case MeasurementType_PR_NOTHING:
1885 case MeasurementType_PR_measName:
1887 free(measItem->measType.choice.measName.buf);
1891 case MeasurementType_PR_measID:
1897 free(actionFormat1->measInfoList.list.array);
1899 free(actionFormat1);
1903 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format2:
1904 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format3:
1905 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format4:
1906 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format5:
1912 /*******************************************************************
1914 * @brief Extract Measurement Info list from action definition
1918 * Function : extractMeasInfoList
1920 * Functionality : This function :
1921 * - Traverses Measurement-to-be-subscribed list
1922 * - Validates that each measurement in Measurement-to-be-subscribed
1923 * list is supported in RAN-Function->Measurement-supported list.
1924 * - If all measurements in an action is supported by RAN function,
1925 * it is added to measurement-subscribed list in local DB
1927 * @params[in] Measurement Info supported list by RAN function
1928 * Measurement Info to be subscribed as requested by RIC
1929 * Measurement Info finally subscribed
1930 * Memory failure indicator
1931 * @return ROK - success
1934 ******************************************************************/
1935 uint8_t extractMeasInfoList(CmLListCp *measInfoSupportedList, MeasurementInfoList_t *measInfoToBeSubscribedList, \
1936 CmLListCp *measInfoSubscribedList, bool *memFailure)
1938 uint8_t elementIdx = 0;
1939 MeasurementInfoForAction *measInfoSupportedDb = NULLP;
1940 MeasurementInfo *measInfoSubscribedDb = NULLP, *measInfoToDel = NULLP;
1941 CmLList *supportedMeasNode = NULLP, *measToAddNode = NULLP, *measToDelNode = NULLP;;
1942 MeasurementInfoItem_t *measItem = NULLP;
1944 /* Validate Measurement list is supported by E2 node.
1946 * Traverse and compare the Measurement-Supported List in E2
1947 * node with Measurement-to-be-subscribed list received from RIC.
1948 * If a match is found, add it to measurement-subscription list.
1950 for(elementIdx = 0; elementIdx < measInfoToBeSubscribedList->list.count; elementIdx++)
1952 measInfoSubscribedDb = NULLP;
1953 measToAddNode = NULLP;
1954 measItem = measInfoToBeSubscribedList->list.array[elementIdx];
1956 CM_LLIST_FIRST_NODE(measInfoSupportedList, supportedMeasNode);
1957 while(supportedMeasNode)
1959 measInfoSupportedDb = (MeasurementInfoForAction*)supportedMeasNode->node;
1960 switch(measItem->measType.present)
1962 case MeasurementType_PR_measName:
1964 if(!strcmp(measInfoSupportedDb->measurementTypeName, (char *)measItem->measType.choice.measName.buf))
1966 DU_ALLOC(measInfoSubscribedDb, sizeof(MeasurementInfo));
1971 case MeasurementType_PR_measID:
1973 if(measInfoSupportedDb->measurementTypeId == measItem->measType.choice.measID)
1975 DU_ALLOC(measInfoSubscribedDb, sizeof(MeasurementInfo));
1982 DU_LOG("\nERROR -> DUAPP: Invalid Measurement-type identifier in \
1983 E2SM-KPM Action Definition Format");
1986 } /* End of switch, for measurement type identifier */
1988 /* If measurement type is supported, add to measurement-subscription list */
1989 if(measInfoSubscribedDb)
1991 measInfoSubscribedDb->measurementTypeId = measInfoSupportedDb->measurementTypeId;
1992 memcpy(measInfoSubscribedDb->measurementTypeName, measInfoSupportedDb->measurementTypeName, \
1993 strlen(measInfoSupportedDb->measurementTypeName));
1995 DU_ALLOC(measToAddNode, sizeof(CmLList));
1998 measToAddNode->node = (PTR) measInfoSubscribedDb;
1999 cmLListAdd2Tail(measInfoSubscribedList, measToAddNode);
2001 /* Break out of while loop if measurement info is found in measurement-supported list */
2006 DU_FREE(measInfoSubscribedDb, sizeof(MeasurementInfo));
2007 measInfoSubscribedDb = NULLP;
2013 supportedMeasNode = supportedMeasNode->next;
2015 } /* End of while for traversing measurement-supported list in a report style */
2017 /* If a measurement-to-be-subscribed is not found in measurement-supported list in this report style
2019 * Delete all entries from measurement-subscription list and
2020 * Break out of for loop to search in next report style */
2021 if(!measInfoSubscribedDb)
2023 while(measInfoSubscribedList->count)
2025 measToDelNode = cmLListDelFrm(measInfoSubscribedList, measInfoSubscribedList->first);
2026 measInfoToDel = (MeasurementInfo*)measToDelNode->node;
2027 DU_FREE(measInfoToDel, sizeof(MeasurementInfo));
2028 DU_FREE(measToDelNode, sizeof(CmLList));
2033 } /* End of for loop , traversing measurement-to-be-subscribed list */
2035 /* If all measurement-to-be-subscribed was found in measurement-supported list and
2036 * was added to measurement-subscription list successfully, return from here */
2037 if(measInfoToBeSubscribedList->list.count == measInfoSubscribedList->count)
2043 /*******************************************************************
2045 * @brief Extract E2SM-KPM Action definition
2049 * Function : extractRicActionDef
2051 * Functionality : This function :
2052 * - Decodes E2SM-KPM Action Definition
2053 * - Validates that action is supported by E2 node
2054 * - Stores action details in local DB
2056 * @params[in] RAN Function Database structure
2057 * RIC subscription's Action definition to be added to
2059 * RIC Action Definition buffer received from RIC
2060 * @return ROK - success
2063 ******************************************************************/
2064 uint8_t extractRicActionDef(RanFunction *ranFuncDb, ActionDefinition *actionDefDb, RICactionDefinition_t *ricActionDef,\
2065 E2FailureCause *failureCause)
2067 bool memFailure = false;
2068 uint8_t styleIdx = 0;
2069 asn_dec_rval_t rval ={0};
2071 E2SM_KPM_ActionDefinition_t actionDef, *actionDefPtr = NULLP;
2072 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
2073 CmLListCp *measInfoSupportedList = NULLP;
2074 CmLListCp *measInfoSubscribedList = NULLP;
2076 /* Decoding E2SM-KPM Action Definition */
2077 actionDefPtr = &actionDef;
2078 memset(actionDefPtr, 0, sizeof(E2SM_KPM_EventTriggerDefinition_t));
2080 rval = aper_decode(0, &asn_DEF_E2SM_KPM_ActionDefinition, (void **)&actionDefPtr, ricActionDef->buf,\
2081 ricActionDef->size, 0, 0);
2082 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2084 DU_LOG("\nERROR --> E2AP : ASN decode failed for E2SM-KPM Action Definition");
2085 failureCause->causeType = E2_PROTOCOL;
2086 failureCause->cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
2090 xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, actionDefPtr);
2093 /* Validate if Report style to subscribe is supported by E2 Node */
2094 for(styleIdx= 0; styleIdx < ranFuncDb->numOfReportStyleSupported; styleIdx++)
2096 /* Validate Report style type and report style format type is supported by E2 Node */
2097 if((ranFuncDb->reportStyleList[styleIdx].reportStyle.styleType == actionDefPtr->ric_Style_Type) &&
2098 (ranFuncDb->reportStyleList[styleIdx].reportStyle.formatType == actionDefPtr->actionDefinition_formats.present))
2100 /* Fetch Report stype type and format type */
2101 actionDefDb->styleType = actionDefPtr->ric_Style_Type;
2102 actionDefDb->formatType = actionDefPtr->actionDefinition_formats.present;
2104 switch(actionDefPtr->actionDefinition_formats.present)
2106 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
2108 actionFormat1 = actionDefPtr->actionDefinition_formats.choice.actionDefinition_Format1;
2110 /* Fetch granularity period */
2111 actionDefDb->choice.format1.granularityPeriod = actionFormat1->granulPeriod;
2113 /* Validate and add the Measurement to subscription list */
2114 measInfoSupportedList = &ranFuncDb->reportStyleList[styleIdx].measurementInfoList;
2115 measInfoSubscribedList = &actionDefDb->choice.format1.measurementInfoList;
2116 if(extractMeasInfoList(measInfoSupportedList, &actionFormat1->measInfoList, \
2117 measInfoSubscribedList, &memFailure) == ROK)
2121 /* Free E2SM_KPM_ActionDefinition_t */
2122 freeAperDecodingOfRicActionDefinition(actionDefPtr);
2127 break; /* End of E2SM-KPM Action definition format 1 case */
2132 DU_LOG("\nERROR -> DUAPP: Only E2SM-KPM Action Definition Format 1 is supported");
2135 } /* End of switch for E2SM-KPM Action definition formats */
2140 failureCause->causeType = E2_MISCELLANEOUS;
2141 failureCause->cause = E2_MISCELLANEOUS_CAUSE_UNSPECIFIED;
2144 } /* End of for loop, traversing Report-styles-supported list in E2 node */
2146 /* Memset action Db and Free E2SM_KPM_ActionDefinition_t */
2147 memset(actionDefDb, 0, sizeof(ActionDefinition));
2148 freeAperDecodingOfRicActionDefinition(actionDefPtr);
2150 if(failureCause->causeType == E2_NOTHING)
2152 failureCause->causeType = E2_RIC_REQUEST;
2153 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
2158 /*******************************************************************
2160 * @brief Extract RIC Action to be setup
2164 * Function : extractRicActionToBeSetup
2166 * Functionality : This function :
2167 * - Validates that each action-to-be-setup is supported by E2 node
2168 * - Stores event trigger details in local DB
2170 * @params[in] RAN Function Database structure
2171 * RIC Subscription Info to be added to RAN function
2172 * RIC Action To Be Setup List received from RIC
2173 * @return ROK - success
2176 ******************************************************************/
2177 uint8_t extractRicActionToBeSetup(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
2178 RICactions_ToBeSetup_List_t *actionList, E2FailureCause *failureCause)
2180 uint8_t actionIdx = 0;
2181 uint8_t ricActionId = 0;
2182 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
2184 if(actionList->list.array)
2186 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
2188 actionItem =(RICaction_ToBeSetup_ItemIEs_t *)actionList->list.array[actionIdx];
2189 switch(actionItem->id)
2191 case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
2193 /* If Action type is REPORT and
2194 * If RIC action definition's extraction and validation passes,
2196 * This action is added to action sequence list of subscription info */
2197 if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType == RICactionType_report)
2199 ricActionId = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID;
2200 ricSubscriptionInfo->actionSequence[ricActionId-1].id = ricActionId;
2201 ricSubscriptionInfo->actionSequence[ricActionId-1].type = REPORT;
2203 if(extractRicActionDef(ranFuncDb, &ricSubscriptionInfo->actionSequence[ricActionId-1].definition, \
2204 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, failureCause) == ROK)
2206 ricSubscriptionInfo->actionSequence[ricActionId-1].action = CONFIG_ADD;
2207 ricSubscriptionInfo->numOfActions++;
2211 memset(&ricSubscriptionInfo->actionSequence[ricActionId-1], 0, sizeof(ActionInfo));
2212 /* TODO : Since this action addition failed, add to
2213 * reject-action-list in subscription response */
2219 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
2225 /* If there is even 1 action that can be added, return ROK */
2226 if(ricSubscriptionInfo->numOfActions)
2229 if(failureCause->causeType == E2_NOTHING)
2231 failureCause->causeType = E2_RIC_REQUEST;
2232 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
2237 /******************************************************************
2239 * @brief Processes RIC Subscription Req sent by RIC
2243 * Function : procRicSubscriptionRequest
2245 * Functionality: Processes RIC Subscription Request from RIC
2247 * @params[in] E2AP_PDU_t ASN decoded E2AP message
2248 * @return ROK - success
2251 * ****************************************************************/
2252 uint8_t procRicSubscriptionRequest(E2AP_PDU_t *e2apMsg)
2256 uint16_t ranFuncId = 0;
2257 RicRequestId ricReqId;
2258 CmLList *ricSubscriptionNode = NULLP;
2259 RanFunction *ranFuncDb = NULLP;
2260 RICsubscriptionRequest_t *ricSubsReq = NULLP;
2261 RICsubscriptionDetails_t *subsDetails = NULLP;
2262 RicSubscription *ricSubscriptionInfo = NULLP;
2263 E2FailureCause failureCause;
2265 DU_LOG("\nINFO --> E2AP : RIC Subscription request received");
2267 memset(&failureCause, 0, sizeof(E2FailureCause));
2268 memset(&ricReqId, 0, sizeof(RicRequestId));
2270 ricSubsReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
2271 for(idx=0; idx<ricSubsReq->protocolIEs.list.count; idx++)
2273 if(ricSubsReq->protocolIEs.list.array[idx])
2275 switch(ricSubsReq->protocolIEs.list.array[idx]->id)
2277 case ProtocolIE_IDE2_id_RICrequestID:
2279 ricReqId.requestorId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID;
2280 ricReqId.instanceId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID;
2285 case ProtocolIE_IDE2_id_RANfunctionID:
2287 ranFuncId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID;
2289 /* Validating RAN Function id */
2290 if(duCb.e2apDb.ranFunction[ranFuncId-1].id == ranFuncId)
2292 ranFuncDb = &duCb.e2apDb.ranFunction[ranFuncId-1];
2294 DU_ALLOC(ricSubscriptionInfo, sizeof(RicSubscription));
2295 if(!ricSubscriptionInfo)
2297 DU_LOG("\nERROR --> E2AP : Memory allocation failed for ricSubscriptionInfo");
2298 failureCause.causeType = E2_MISCELLANEOUS;
2299 failureCause.cause = E2_MISCELLANEOUS_CAUSE_UNSPECIFIED;
2303 ricSubscriptionInfo->requestId.requestorId = ricReqId.requestorId;
2304 ricSubscriptionInfo->requestId.instanceId = ricReqId.instanceId;
2308 failureCause.causeType = E2_RIC_REQUEST;
2309 failureCause.cause = E2_RAN_FUNCTION_ID_INVALID;
2315 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
2317 subsDetails = &ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails;
2319 /* Decode, Validate and record Event Trigger Definition */
2320 if(extractEventTriggerDef(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricEventTriggerDefinition, \
2321 &failureCause) != ROK)
2327 /* Decode, Validate and record RIC actions */
2328 if(extractRicActionToBeSetup(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricAction_ToBeSetup_List, \
2329 &failureCause) != ROK)
2338 DU_LOG("\nERROR --> E2AP : Invalid IE received in RIC SubsReq:%ld",
2339 ricSubsReq->protocolIEs.list.array[idx]->id);
2348 freeAperDecodingOfRicSubsReq(ricSubsReq);
2352 /* Add RAN subcription detail to RAN function */
2353 DU_ALLOC(ricSubscriptionNode, sizeof(CmLList));
2354 if(ricSubscriptionNode)
2356 ricSubscriptionNode->node = (PTR) ricSubscriptionInfo;
2357 cmLListAdd2Tail(&ranFuncDb->subscriptionList, ricSubscriptionNode);
2360 #ifdef KPI_CALCULATION
2361 /* Send statistics request to other DU entities */
2362 BuildAndSendStatsReq(ranFuncId, ricSubscriptionInfo);
2365 /* TODO : Trigger RIC subscription response once statistics response is
2366 * received from MAC .
2367 * TBD in next gerrit */
2368 ret = BuildAndSendRicSubscriptionRsp();
2370 BuildAndSendRicIndication(ricSubscriptionInfo);
2375 DU_FREE(ricSubscriptionInfo, sizeof(RicSubscription));
2377 /* Send RIC Subcription Failure */
2378 BuildAndSendRicSubscriptionFailure(ricReqId, ranFuncId, failureCause);
2384 /******************************************************************
2386 * @brief Free RIC Subscription Failure
2390 * Function : FreeRicSubscriptionFailure
2392 * Functionality: Free RIC Subscription Failure
2394 * @params[in] E2AP PDU
2397 * ****************************************************************/
2398 void FreeRicSubscriptionFailure(E2AP_PDU_t *e2apMsg)
2400 uint8_t elemIdx = 0;
2401 RICsubscriptionFailure_t *ricSubscriptionFailure = NULLP;
2405 if(e2apMsg->choice.unsuccessfulOutcome)
2407 ricSubscriptionFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
2408 if(ricSubscriptionFailure->protocolIEs.list.array)
2410 for(elemIdx = 0; elemIdx < ricSubscriptionFailure->protocolIEs.list.count; elemIdx++)
2412 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array[elemIdx], sizeof(RICsubscriptionFailure_IEs_t));
2414 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array, ricSubscriptionFailure->protocolIEs.list.size);
2416 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
2418 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2422 /******************************************************************
2424 * @brief Fill and Send RIC Subscription Failure to RIC
2428 * Function : BuildAndSendRicSubscriptionFailure
2430 * Functionality: Fill and Send RIC Subscription Failure to RIC
2432 * @params[in] RIC Request ID
2435 * @return ROK - success
2438 * ****************************************************************/
2439 uint8_t BuildAndSendRicSubscriptionFailure(RicRequestId ricReqId, uint16_t ranFuncId, E2FailureCause failureCause)
2441 uint8_t ret = RFAILED;
2442 uint8_t elementCnt = 0, elemIdx = 0;
2443 E2AP_PDU_t *e2apMsg = NULLP;
2444 asn_enc_rval_t encRetVal; /* Encoder return value */
2445 RICsubscriptionFailure_t *ricSubscriptionFailure = NULLP;
2446 RICsubscriptionFailure_IEs_t *ricSubsFailIe = NULLP;
2450 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Failure\n");
2452 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2453 if(e2apMsg == NULLP)
2455 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
2459 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
2460 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
2461 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
2463 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
2466 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
2467 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
2468 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionFailure;
2470 ricSubscriptionFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
2473 ricSubscriptionFailure->protocolIEs.list.count = elementCnt;
2474 ricSubscriptionFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionFailure_IEs_t *);
2475 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array, ricSubscriptionFailure->protocolIEs.list.size);
2476 if(!ricSubscriptionFailure->protocolIEs.list.array)
2478 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
2482 for(elemIdx = 0; elemIdx < elementCnt; elemIdx++)
2484 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array[elemIdx], sizeof(RICsubscriptionFailure_IEs_t));
2485 if(!ricSubscriptionFailure->protocolIEs.list.array[elemIdx])
2487 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d] for IE at index [%d]", \
2488 __func__, __LINE__, elemIdx);
2492 if(elemIdx < elementCnt)
2497 /* RIC Request ID */
2498 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
2499 ricSubsFailIe->id = ProtocolIE_IDE2_id_RICrequestID;
2500 ricSubsFailIe->criticality = CriticalityE2_reject;
2501 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_RICrequestID;
2502 ricSubsFailIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
2503 ricSubsFailIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
2505 /* RAN Function ID */
2506 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
2507 ricSubsFailIe->id = ProtocolIE_IDE2_id_RANfunctionID;
2508 ricSubsFailIe->criticality = CriticalityE2_reject;
2509 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_RANfunctionID;
2510 ricSubsFailIe->value.choice.RANfunctionID = ranFuncId;
2513 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
2514 ricSubsFailIe->id = ProtocolIE_IDE2_id_CauseE2;
2515 ricSubsFailIe->criticality = CriticalityE2_reject;
2516 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_CauseE2;
2517 fillE2Cause(&ricSubsFailIe->value.choice.CauseE2, failureCause);
2519 /* Prints the Msg formed */
2520 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2521 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2523 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2524 if(encRetVal.encoded == ENCODE_FAIL)
2526 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Failure Message (at %s)\n",\
2527 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2532 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Failure Message \n");
2533 #ifdef DEBUG_ASN_PRINT
2534 for(int i=0; i< encBufSize; i++)
2536 printf("%x",encBuf[i]);
2541 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
2543 DU_LOG("\nINFO --> E2AP : Sending RIC Subscription Failure");
2549 FreeRicSubscriptionFailure(e2apMsg);
2553 /*******************************************************************
2555 * @brief Free the RicIndication Message
2559 * Function : FreeRicIndication
2561 * Functionality: Free the RicIndication Message
2566 ******************************************************************/
2567 void FreeRicIndication(E2AP_PDU_t *e2apMsg)
2570 RICindication_t *ricIndicationMsg= NULLP;
2572 if(e2apMsg != NULLP)
2574 if(e2apMsg->choice.initiatingMessage != NULLP)
2576 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
2577 if(ricIndicationMsg!= NULLP)
2579 if(ricIndicationMsg->protocolIEs.list.array != NULLP)
2581 for(idx=0; idx<ricIndicationMsg->protocolIEs.list.count; idx++)
2583 if(ricIndicationMsg->protocolIEs.list.array[idx] != NULLP)
2585 switch(ricIndicationMsg->protocolIEs.list.array[idx]->id)
2587 case ProtocolIE_IDE2_id_RICrequestID:
2590 case ProtocolIE_IDE2_id_RANfunctionID:
2593 case ProtocolIE_IDE2_id_RICactionID:
2596 case ProtocolIE_IDE2_id_RICindicationType:
2599 case ProtocolIE_IDE2_id_RICindicationHeader:
2601 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf,\
2602 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
2605 case ProtocolIE_IDE2_id_RICindicationMessage:
2607 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf,\
2608 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
2614 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx],sizeof(RICindication_IEs_t));
2617 DU_FREE(ricIndicationMsg->protocolIEs.list.array,ricIndicationMsg->protocolIEs.list.size);
2620 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2622 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2626 /*******************************************************************
2628 * brief Fill the RicIndication Message
2632 * Function : FillRicIndication
2634 * Functionality:Fills the RicIndication Message
2636 * @return ROK - success
2639 ******************************************************************/
2640 uint8_t FillRicIndication(RICindication_t *ricIndicationMsg, RicSubscription *ricSubscriptionInfo)
2642 uint8_t elementCnt=0;
2647 ricIndicationMsg->protocolIEs.list.count = elementCnt;
2648 ricIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(RICindication_t);
2649 /* Initialize the Ric Indication members */
2650 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array, \
2651 ricIndicationMsg->protocolIEs.list.size);
2652 if(ricIndicationMsg->protocolIEs.list.array == NULLP)
2654 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
2659 for(idx=0; idx<elementCnt; idx++)
2661 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx],\
2662 sizeof(RICindication_IEs_t));
2663 if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP)
2665 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
2673 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
2674 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
2675 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
2676 RICindication_IEs__value_PR_RICrequestID;
2677 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID =ricSubscriptionInfo->requestId.requestorId;
2678 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID = ricSubscriptionInfo->requestId.instanceId;
2681 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
2682 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
2683 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
2684 RICindication_IEs__value_PR_RANfunctionID;
2685 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RANfunctionID = duCb.e2apDb.ranFunction[0].id;
2688 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionID;
2689 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
2690 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
2691 RICindication_IEs__value_PR_RICactionID;
2692 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICactionID = ricSubscriptionInfo->actionSequence[0].id;
2695 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationType;
2696 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
2697 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
2698 RICindication_IEs__value_PR_RICindicationType;
2699 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationType = ricSubscriptionInfo->actionSequence[0].type;
2702 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationHeader;
2703 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
2704 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
2705 RICindication_IEs__value_PR_RICindicationHeader;
2706 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size = 3 *
2708 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf ,\
2709 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
2710 if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf == NULLP)
2712 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
2717 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
2718 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf);
2720 /* TO BE CHANGED: RIC INDICATION DATA */
2721 /* For now filling a dummy octect data, need to tested with PRBs*/
2722 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationMessage;
2723 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
2724 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
2725 RICindication_IEs__value_PR_RICindicationMessage;
2726 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size = 3 *
2728 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf ,\
2729 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
2730 if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf == NULLP)
2732 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
2737 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
2738 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf);
2746 /*******************************************************************
2748 * @brief Builds and Send the RicIndication Message
2752 * Function : BuildAndSendRicIndication
2754 * Functionality:Fills the RicIndication Message
2756 * @return ROK - success
2759 ******************************************************************/
2761 uint8_t BuildAndSendRicIndication(RicSubscription *ricSubscriptionInfo)
2763 E2AP_PDU_t *e2apMsg = NULLP;
2764 RICindication_t *ricIndicationMsg=NULLP;
2765 asn_enc_rval_t encRetVal; /* Encoder return value */
2766 uint8_t ret = RFAILED;
2767 uint8_t FillRicIndicationret = ROK;
2771 DU_LOG("\nINFO --> E2AP : Building RIC Indication Message\n");
2773 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2774 if(e2apMsg == NULLP)
2776 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2780 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
2781 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2782 if(e2apMsg->choice.initiatingMessage == NULLP)
2784 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2787 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication;
2788 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
2789 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICindication;
2791 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
2793 FillRicIndicationret = FillRicIndication(ricIndicationMsg, ricSubscriptionInfo);
2794 if(FillRicIndicationret != ROK)
2798 /* Prints the Msg formed */
2799 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2800 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2802 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
2804 if(encRetVal.encoded == ENCODE_FAIL)
2806 DU_LOG("\nERROR --> E2AP : Could not encode RIC Indication Message (at %s)\n",\
2807 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2812 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Indication Message \n");
2813 #ifdef DEBUG_ASN_PRINT
2814 for(int i=0; i< encBufSize; i++)
2816 printf("%x",encBuf[i]);
2821 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
2823 DU_LOG("\nINFO --> E2AP : Sending RIC Indication Message");
2829 FreeRicIndication(e2apMsg);
2833 /*******************************************************************
2835 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
2839 * Function : FreeE2NodeConfigUpdate
2842 * - freeing the memory allocated for E2nodeConfigurationUpdate
2844 * @params[in] E2AP_PDU_t *e2apMsg
2845 * @return ROK - success
2848 * ****************************************************************/
2849 void FreeE2NodeConfigUpdate(E2AP_PDU_t *e2apMsg)
2852 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate;
2854 if(e2apMsg != NULLP)
2856 if(e2apMsg->choice.initiatingMessage != NULLP)
2858 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
2859 if(e2NodeConfigUpdate->protocolIEs.list.array != NULLP)
2861 for(arrIdx = 0; arrIdx < e2NodeConfigUpdate->protocolIEs.list.count; arrIdx++)
2863 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
2865 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
2867 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2869 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2873 /*******************************************************************
2875 * @brief Buld and send the E2 node config update msg
2879 * Function : BuildAndSendE2NodeConfigUpdate
2882 * - Buld and send the E2 node config update msg
2885 * @return ROK - success
2888 * ****************************************************************/
2890 uint8_t BuildAndSendE2NodeConfigUpdate()
2892 uint8_t arrIdx = 0,elementCnt = 1;
2894 E2AP_PDU_t *e2apMsg = NULLP;
2895 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate = NULLP;
2896 asn_enc_rval_t encRetVal; /* Encoder return value */
2898 DU_LOG("\nINFO --> E2AP : Building E2 Node config update\n");
2901 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2902 if(e2apMsg == NULLP)
2904 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2907 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
2908 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2909 if(e2apMsg->choice.initiatingMessage == NULLP)
2911 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2912 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2915 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
2916 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
2917 e2apMsg->choice.initiatingMessage->value.present = \
2918 InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate;
2919 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
2921 e2NodeConfigUpdate->protocolIEs.list.count = elementCnt;
2922 e2NodeConfigUpdate->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdate_IEs_t*);
2923 /* Initialize the Ric Indication members */
2924 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array, \
2925 e2NodeConfigUpdate->protocolIEs.list.size);
2926 if(e2NodeConfigUpdate->protocolIEs.list.array == NULLP)
2928 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
2932 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
2934 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
2935 if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx] == NULLP)
2938 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
2945 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2946 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2947 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_TransactionID;
2948 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = TRANS_ID;
2951 /* Prints the Msg formed */
2952 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2954 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2956 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
2958 if(encRetVal.encoded == ENCODE_FAIL)
2960 DU_LOG("\nERROR --> E2AP : Could not encode E2nodeConfigurationUpdate structure (at %s)\n",\
2961 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2966 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2nodeConfigurationUpdate\n");
2967 #ifdef DEBUG_ASN_PRINT
2968 for(int i=0; i< encBufSize; i++)
2970 printf("%x",encBuf[i]);
2974 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize))
2976 DU_LOG("\nERROR --> E2AP : Sending E2 node config update failed");
2983 FreeE2NodeConfigUpdate(e2apMsg);
2987 /*******************************************************************
2989 * @brief Deallocate the memory allocated for E2ResetRequest msg
2993 * Function : FreeE2ResetRequest
2996 * - freeing the memory allocated for E2ResetRequest
2998 * @params[in] E2AP_PDU_t *e2apMsg
2999 * @return ROK - success
3002 * ****************************************************************/
3003 void FreeE2ResetRequest(E2AP_PDU_t *e2apMsg)
3006 ResetRequestE2_t *resetReq = NULLP;
3008 if(e2apMsg != NULLP)
3010 if(e2apMsg->choice.initiatingMessage != NULLP)
3012 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
3013 if(resetReq->protocolIEs.list.array)
3015 for(ieIdx = 0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
3017 DU_FREE(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
3019 DU_FREE(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
3021 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
3023 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3027 /*******************************************************************
3029 * @brief Build and send the E2 reset request msg
3033 * Function : BuildAndSendE2ResetRequest
3036 * - Buld and send the E2 reset request msg to RIC
3039 * @return ROK - success
3042 * ****************************************************************/
3043 uint8_t BuildAndSendE2ResetRequest(E2FailureCause resetCause)
3045 uint8_t ieIdx = 0, elementCnt = 0, transId = 0;
3046 uint8_t ret = RFAILED;
3047 E2AP_PDU_t *e2apMsg = NULLP;
3048 ResetRequestE2_t *resetReq = NULLP;
3049 asn_enc_rval_t encRetVal; /* Encoder return value */
3051 DU_LOG("\nINFO --> E2AP : Building E2 Reset Request\n");
3055 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3056 if(e2apMsg == NULLP)
3058 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for E2AP-PDU failed");
3062 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
3063 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
3064 if(e2apMsg->choice.initiatingMessage == NULLP)
3066 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for initiatingMessage");
3070 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset;
3071 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
3072 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2;
3073 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
3076 resetReq->protocolIEs.list.count = elementCnt;
3077 resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *);
3079 DU_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
3080 if(!resetReq->protocolIEs.list.array)
3082 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
3083 Reset Request IE array");
3087 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
3089 DU_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
3090 if(!resetReq->protocolIEs.list.array[ieIdx])
3092 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
3093 Reset Request IE array element");
3098 /* In case of failure */
3099 if(ieIdx < elementCnt)
3103 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
3104 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
3105 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID;
3106 transId = assignTransactionId();
3107 resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
3110 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
3111 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
3112 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2;
3113 fillE2Cause(&resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, resetCause);
3115 /* Prints the Msg formed */
3116 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3118 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3120 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
3122 if(encRetVal.encoded == ENCODE_FAIL)
3124 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\
3125 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3130 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n");
3131 #ifdef DEBUG_ASN_PRINT
3132 for(int i=0; i< encBufSize; i++)
3134 printf("%x",encBuf[i]);
3138 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
3140 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
3144 /* In case the message is sent successfully, store the transaction info to
3145 * be used when response is received */
3146 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
3147 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
3153 /* Free all memory */
3154 FreeE2ResetRequest(e2apMsg);
3158 /*******************************************************************
3160 * @brief Deallocate the memory allocated for Reset Response msg
3164 * Function : freeAperDecodingOfE2ResetRsp
3167 * - freeing the memory allocated for Reset response
3169 * @params[in] ResetResponseE2_t *resetResponse
3172 * ****************************************************************/
3173 void freeAperDecodingOfE2ResetRsp(ResetResponseE2_t *resetResponse)
3179 if(resetResponse->protocolIEs.list.array)
3181 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
3183 if(resetResponse->protocolIEs.list.array[ieIdx])
3185 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
3187 case ProtocolIE_IDE2_id_TransactionID:
3190 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
3193 free(resetResponse->protocolIEs.list.array[ieIdx]);
3196 free(resetResponse->protocolIEs.list.array);
3201 /******************************************************************
3203 * @brief Processes E2 Reset Response sent by RIC
3207 * Function : procResetResponse
3209 * Functionality: Processes E2 Reset Response sent by RIC
3211 * @params[in] E2AP_PDU_t ASN decoded E2AP message
3212 * @return ROK - success
3215 * ****************************************************************/
3216 uint8_t procResetResponse(E2AP_PDU_t *e2apMsg)
3218 uint8_t ieIdx =0, transId;
3219 ResetResponseE2_t *resetResponse;
3221 DU_LOG("\nINFO --> E2AP : E2 Reset Response received");
3222 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;;
3224 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
3226 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
3228 case ProtocolIE_IDE2_id_TransactionID:
3229 transId = resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
3230 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) && \
3231 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
3233 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
3237 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
3241 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
3242 /* As per ORAN WG3 E2AP spec v3.0, section 9.2.2
3243 Criticality Diagnostics IE is sent by Near-RT RIC when parts of a received message i.e.
3244 Reset Request in this case, have not been comprehended or were missing, or if the message
3245 contained logical errors.
3247 Processing of this ID should be implemented when negative call flows are to be supported.
3251 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2 Reset Response : %ld",
3252 resetResponse->protocolIEs.list.array[ieIdx]->id);
3257 freeAperDecodingOfE2ResetRsp(resetResponse);
3261 /******************************************************************
3263 * @brief Deallocation of memory allocated bu aper decoder for e2 setup Failure
3267 * Function : freeAperDecodingOfE2SetupFailure
3269 * Functionality: Deallocation of memory allocated bu aper decoder for e2
3272 * @params[in] E2setupFailure_t *e2SetupFailure;
3275 * ****************************************************************/
3276 void freeAperDecodingOfE2SetupFailure(E2setupFailure_t *e2SetupFailure)
3282 if(e2SetupFailure->protocolIEs.list.array)
3284 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
3286 if(e2SetupFailure->protocolIEs.list.array[arrIdx])
3288 free(e2SetupFailure->protocolIEs.list.array[arrIdx]);
3291 free(e2SetupFailure->protocolIEs.list.array);
3295 /******************************************************************
3297 * @brief Processes E2 Setup Failure sent by RIC
3301 * Function : procE2SetupFailure
3303 * Functionality: Processes E2 Setup failure sent by RIC
3305 * @params[in] E2AP_PDU_t ASN decoded E2AP message
3306 * @return ROK - success
3309 * ****************************************************************/
3310 void procE2SetupFailure(E2AP_PDU_t *e2apMsg)
3312 uint8_t arrIdx =0, transId =0, timerValue=0;
3313 E2setupFailure_t *e2SetupFailure;
3315 DU_LOG("\nINFO --> E2AP : E2 Setup failure received");
3316 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
3318 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
3320 switch(e2SetupFailure->protocolIEs.list.array[arrIdx]->id)
3322 case ProtocolIE_IDE2_id_TransactionID:
3324 transId = e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
3325 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
3326 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
3328 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
3332 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
3337 case ProtocolIE_IDE2_id_TimeToWaitE2:
3339 timerValue = covertE2WaitTimerEnumToValue(e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
3340 if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR)) == FALSE)
3342 duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR, timerValue);
3346 DU_LOG("\nERROR --> E2AP : EVENT_E2_SETUP_TMR timer is already running");
3354 freeAperDecodingOfE2SetupFailure(e2SetupFailure);
3356 /******************************************************************
3358 * @brief Deallocation of memory allocated bu aper decoder for RIC service Query
3362 * Function : freeAperDecodingOfRicServiceQuery
3364 * Functionality: Deallocation of memory allocated bu aper decoder for RIC
3367 * @params[in] RICserviceQuery_t *ricServiceQuery;
3370 * ****************************************************************/
3372 void freeAperDecodingOfRicServiceQuery(RICserviceQuery_t *ricServiceQuery)
3374 uint8_t arrIdx,ranFuncIdx;
3375 RANfunctionsID_List_t *ranFuncAddedList;
3379 if(ricServiceQuery->protocolIEs.list.array)
3381 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
3383 if(ricServiceQuery->protocolIEs.list.array[arrIdx])
3385 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
3387 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
3389 ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
3390 if(ranFuncAddedList->list.array)
3392 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
3394 free(ranFuncAddedList->list.array[ranFuncIdx]);
3396 free(ranFuncAddedList->list.array);;
3403 free(ricServiceQuery->protocolIEs.list.array[arrIdx]);
3406 free(ricServiceQuery->protocolIEs.list.array);
3410 /*******************************************************************
3412 * @brief Build RanFunction Delete List
3416 * Function : BuildRanFunctionDeleteList
3418 * Functionality: Build RanFunction Delete List
3421 * RANfunctionsID List
3422 * Count of the RAN function
3423 * Received RAN function list
3425 * @return ROK - success
3428 ******************************************************************/
3430 uint8_t BuildRanFunctionDeleteList(RANfunctionsID_List_t *deleteList, uint8_t count, RanFuncInfo *recvdRanFunc)
3432 uint8_t ranFuncIdx=0;
3433 RANfunctionID_ItemIEs_t *delRanFuncItem;
3437 deleteList->list.count = count;
3438 deleteList->list.size = deleteList->list.count * sizeof(RANfunctionID_ItemIEs_t*);
3439 DU_ALLOC(deleteList->list.array, deleteList->list.size);
3440 if(deleteList->list.array == NULLP)
3442 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
3445 for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++)
3447 DU_ALLOC(deleteList->list.array[ranFuncIdx], sizeof(RANfunctionID_ItemIEs_t));
3448 if(deleteList->list.array[ranFuncIdx] == NULLP)
3450 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
3453 delRanFuncItem= (RANfunctionID_ItemIEs_t *) deleteList->list.array[ranFuncIdx];
3454 delRanFuncItem->id = ProtocolIE_IDE2_id_RANfunctionID_Item;
3455 delRanFuncItem->criticality = CriticalityE2_ignore;
3456 delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionID = recvdRanFunc[ranFuncIdx].id;
3457 delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionRevision = recvdRanFunc[ranFuncIdx].revisionCounter;
3463 /*******************************************************************
3465 * @brief De Allocate Ric Service Update message
3469 * Function : FreeRicServiceUpdate
3471 * Functionality: De-Allocating Ric Service Update message
3473 * @params[in] E2AP_PDU_t *e2apMsg
3477 * ****************************************************************/
3479 void FreeRicServiceUpdate(E2AP_PDU_t *e2apMsg)
3482 uint8_t ranFuncAddListIdx=0, ranFuncDelIdx=0;
3483 RICserviceUpdate_t *ricServiceUpdate;
3484 RANfunctions_List_t *ranFunctionsList;
3485 RANfunction_ItemIEs_t *ranFuncItemIe;
3486 RANfunction_Item_t *ranFunItem;
3487 RANfunctionsID_List_t *deleteList;
3489 /* De-allocating Memory */
3490 if(e2apMsg != NULLP)
3492 if(e2apMsg->choice.initiatingMessage != NULLP)
3494 ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate;
3495 if(ricServiceUpdate->protocolIEs.list.array != NULLP)
3497 for(arrIdx = 0; arrIdx < ricServiceUpdate->protocolIEs.list.count; arrIdx++)
3499 if(ricServiceUpdate->protocolIEs.list.array[arrIdx] != NULLP)
3501 switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id)
3503 case ProtocolIE_IDE2_id_TransactionID:
3506 case ProtocolIE_IDE2_id_RANfunctionsAdded:
3507 case ProtocolIE_IDE2_id_RANfunctionsModified:
3509 ranFunctionsList = &(ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List);
3510 if(ranFunctionsList->list.array)
3512 for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++)
3514 if(ranFunctionsList->list.array[ranFuncAddListIdx])
3516 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx];
3517 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
3518 DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size);
3519 DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size);
3520 DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t));
3523 DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size);
3527 case ProtocolIE_IDE2_id_RANfunctionsDeleted:
3529 deleteList= &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
3530 if(deleteList->list.array)
3532 for(ranFuncDelIdx = 0; ranFuncDelIdx< deleteList->list.count; ranFuncDelIdx++)
3534 DU_FREE(deleteList->list.array[ranFuncDelIdx], sizeof(RANfunctionID_ItemIEs_t));
3536 DU_FREE(deleteList->list.array, deleteList->list.size);
3542 DU_LOG("\nERROR --> E2AP: Invalid event at ricServiceUpdate %ld ",\
3543 (ricServiceUpdate->protocolIEs.list.array[arrIdx]->id));
3546 DU_FREE(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t));
3549 DU_FREE(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
3551 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
3553 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3557 /*******************************************************************
3559 * @brief Builds and Send the RicServiceUpdateuest
3563 * Function : BuildAndSendRicServiceUpdate
3565 * Functionality:Fills the RicServiceUpdateuest
3567 * @return ROK - success
3570 ******************************************************************/
3572 uint8_t BuildAndSendRicServiceUpdate(RicServiceUpdate serviceUpdate)
3574 uint8_t arrIdx = 0, elementCnt=0;
3575 uint8_t transId = 0, ret = RFAILED;
3576 bool memAllocFailed =false;
3577 E2AP_PDU_t *e2apMsg = NULLP;
3578 RICserviceUpdate_t *ricServiceUpdate = NULLP;
3579 asn_enc_rval_t encRetVal; /* Encoder return value */
3581 DU_LOG("\nINFO --> E2AP : Building Ric Service Update\n");
3584 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3585 if(e2apMsg == NULLP)
3587 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3590 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
3591 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
3592 if(e2apMsg->choice.initiatingMessage == NULLP)
3594 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
3597 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
3598 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
3599 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceUpdate;
3600 ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate;
3602 /* For TransId IE, set elementCnt to 1.
3603 If there is any item in the RAN function add list, RAN function modification list, or RAN function delete list, increment the elementCnt.*/
3606 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
3608 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified)
3610 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted)
3613 ricServiceUpdate->protocolIEs.list.count = elementCnt;
3614 ricServiceUpdate->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdate_IEs_t*);
3616 /* Initialize the E2Setup members */
3617 DU_ALLOC(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
3618 if(ricServiceUpdate->protocolIEs.list.array == NULLP)
3620 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
3624 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
3626 DU_ALLOC(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t));
3627 if(ricServiceUpdate->protocolIEs.list.array[arrIdx] == NULLP)
3629 memAllocFailed = true;
3630 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayIdx [%d]", arrIdx);
3634 if(memAllocFailed == true)
3640 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
3641 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3642 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
3643 if(serviceUpdate.dir == E2_NODE_INITIATED)
3644 transId = assignTransactionId();
3646 transId = serviceUpdate.transId;
3647 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
3649 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
3652 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded;
3653 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3654 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
3655 if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,\
3656 e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded, serviceUpdate.recvRanFuncList.ranFunToBeAdded) !=ROK)
3662 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified)
3665 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsModified;
3666 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3667 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
3668 if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,
3669 e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeModified, serviceUpdate.recvRanFuncList.ranFunToBeModified) !=ROK)
3675 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted)
3678 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsDeleted;
3679 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
3680 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctionsID_List;
3681 if(BuildRanFunctionDeleteList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List,\
3682 serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted, serviceUpdate.recvRanFuncList.ranFunToBeDeleted) != ROK)
3687 /* Prints the Msg formed */
3688 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3690 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3692 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3693 if(encRetVal.encoded == ENCODE_FAIL)
3695 DU_LOG("\nERROR --> E2AP : Could not encode RicServiceUpdateuest structure (at %s)\n",\
3696 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3701 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicServiceUpdateuest\n");
3702 #ifdef DEBUG_ASN_PRINT
3703 for(int i=0; i< encBufSize; i++)
3705 printf("%x",encBuf[i]);
3709 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
3711 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
3720 if(serviceUpdate.dir == E2_NODE_INITIATED)
3722 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
3723 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
3727 duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId = transId;
3728 duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
3730 duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.dir = serviceUpdate.dir;
3731 duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.transId =transId;
3732 memcpy(&duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.recvRanFuncList, &serviceUpdate.recvRanFuncList, sizeof(E2TmpRanFunList));
3734 FreeRicServiceUpdate(e2apMsg);
3737 /******************************************************************
3739 * @brief Processes RIC service Query sent by RIC
3743 * Function : procRicServiceQuery
3745 * Functionality: Processes RIC service Query sent by RIC
3747 * @params[in] E2AP_PDU_t ASN decoded E2AP message
3748 * @return ROK - success
3751 * ****************************************************************/
3753 void procRicServiceQuery(E2AP_PDU_t *e2apMsg)
3756 uint16_t arrIdx =0, ranFuncIdx=0,tmpIdx=0;
3757 uint16_t id,revisionCcounter;
3758 bool tmpArray[MAX_RAN_FUNCTION] = {false};
3759 RICserviceQuery_t *ricServiceQuery=NULL;
3760 RicServiceUpdate ricUpdate;
3761 RANfunctionID_ItemIEs_t *ranFuncAddedItemIe;
3762 RANfunctionsID_List_t *ranFuncAddedList;
3764 DU_LOG("\nINFO --> E2AP : RIC Service Query received");
3765 memset(&ricUpdate, 0, sizeof(RicServiceUpdate));
3766 ricUpdate.dir = RIC_INITIATED;
3767 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
3769 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
3771 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
3773 /* TODO completing in next patch/gerrit */
3774 case ProtocolIE_IDE2_id_TransactionID:
3776 ricUpdate.transId = ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
3780 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
3782 ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
3783 if(ranFuncAddedList->list.array)
3785 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
3787 if(ranFuncAddedList->list.array[ranFuncIdx])
3789 /* Using the RAN function Id, identify the RAN function to be modified or deleted. */
3791 ranFuncAddedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAddedList->list.array[ranFuncIdx];
3792 id = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionID;
3793 revisionCcounter = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision;
3795 if((id != duCb.e2apDb.ranFunction[id-1].id))
3797 action = CONFIG_DEL;
3799 else if((id == duCb.e2apDb.ranFunction[id-1].id)&&(revisionCcounter!=duCb.e2apDb.ranFunction[id-1].revisionCounter))
3801 action = CONFIG_MOD;
3804 if(action == CONFIG_DEL)
3806 ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].id = id;
3807 ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].revisionCounter = revisionCcounter;
3808 ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted++;
3810 else if(action == CONFIG_MOD)
3812 ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].id = id;
3813 ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].revisionCounter = revisionCcounter;
3814 ricUpdate.recvRanFuncList.numOfRanFunToBeModified++;
3817 /* If any ID is set to true, it means that the ID has been used in either modification or deletion list.
3818 * Else we will add the IDs into the added list */
3819 tmpArray[id-1] = true;
3828 /* Traversing the whole RAN function list in ducb to check if any new Ran function ids have been added. */
3829 for(arrIdx =0; arrIdx<MAX_RAN_FUNCTION; arrIdx++)
3831 tmpIdx= ricUpdate.recvRanFuncList.numOfRanFunToBeAdded;
3832 if((duCb.e2apDb.ranFunction[arrIdx].id >0)&&(!tmpArray[arrIdx]))
3834 ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[arrIdx].id;
3835 ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[arrIdx].revisionCounter;
3836 ricUpdate.recvRanFuncList.numOfRanFunToBeAdded++;
3840 if(BuildAndSendRicServiceUpdate(ricUpdate)!= ROK)
3842 DU_LOG("\nERROR --> E2AP : Failed to build and send ric service update message");
3845 freeAperDecodingOfRicServiceQuery(ricServiceQuery);
3848 /******************************************************************
3850 * @brief Deallocation of memory allocated by aper decoder for
3851 * RIC service update ack
3855 * Function : freeAperDecodingOfRicServiceUpdateAck
3857 * Functionality: Deallocation of memory allocated by aper decoder
3858 * for RIC service update ack
3860 * @params[in] RICserviceUpdateAck_t *ricServiceAck;
3863 * ****************************************************************/
3865 void freeAperDecodingOfRicServiceUpdateAck(RICserviceUpdateAcknowledge_t *ricServiceAck)
3867 uint8_t arrIdx=0,ranFuncIdx=0;
3868 RANfunctionsID_List_t *ranFuncAddedList=NULL;
3872 if(ricServiceAck->protocolIEs.list.array)
3874 for(arrIdx=0; arrIdx<ricServiceAck->protocolIEs.list.count; arrIdx++)
3876 if(ricServiceAck->protocolIEs.list.array[arrIdx])
3878 switch(ricServiceAck->protocolIEs.list.array[arrIdx]->id)
3880 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
3882 ranFuncAddedList= &ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
3883 if(ranFuncAddedList->list.array)
3885 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
3887 free(ranFuncAddedList->list.array[ranFuncIdx]);
3889 free(ranFuncAddedList->list.array);
3896 free(ricServiceAck->protocolIEs.list.array[arrIdx]);
3899 free(ricServiceAck->protocolIEs.list.array);
3904 /******************************************************************
3906 * @brief Processes RIC service update ack sent by RIC
3910 * Function : procRicServiceUpdateAck
3912 * Functionality: Processes RIC service update ack sent by RIC
3914 * @params[in] E2AP_PDU_t ASN decoded E2AP message
3915 * @return ROK - success
3918 * ****************************************************************/
3920 void procRicServiceUpdateAck(E2AP_PDU_t *e2apMsg)
3922 uint8_t arrIdx =0, transId =0;
3923 uint16_t id =0, tmpIdx=0, ranFuncIdx=0;
3924 RicServiceUpdate serviceUpdate;
3925 RANfunctionsIDcause_List_t *rejectedList=NULL;
3926 RICserviceUpdateAcknowledge_t *ricServiceAck=NULL;
3927 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
3929 DU_LOG("\nINFO --> E2AP : RIC service update ack received");
3930 memset(&serviceUpdate, 0, sizeof(RicServiceUpdate));
3931 ricServiceAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
3933 for(arrIdx=0; arrIdx<ricServiceAck->protocolIEs.list.count; arrIdx++)
3935 switch(ricServiceAck->protocolIEs.list.array[arrIdx]->id)
3937 case ProtocolIE_IDE2_id_TransactionID:
3939 transId = ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
3940 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
3941 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
3943 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
3945 else if((duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId == transId) &&\
3946 (duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
3948 memset(&duCb.e2apDb.e2TransInfo.ricInitTransaction[transId], 0, sizeof(E2TransInfo));
3952 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
3958 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
3961 case ProtocolIE_IDE2_id_RANfunctionsRejected:
3963 rejectedList= &ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
3964 if(rejectedList->list.array)
3966 for(ranFuncIdx=0;ranFuncIdx<rejectedList->list.count; ranFuncIdx++)
3968 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)rejectedList->list.array[ranFuncIdx];
3969 id = ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID;
3970 tmpIdx= serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded;
3971 serviceUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[id-1].id;
3972 serviceUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[id-1].revisionCounter;
3973 serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded++;
3982 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
3984 serviceUpdate.dir = E2_NODE_INITIATED;
3985 BuildAndSendRicServiceUpdate(serviceUpdate);
3987 freeAperDecodingOfRicServiceUpdateAck(ricServiceAck);
3990 /******************************************************************
3992 * @brief Deallocation of memory allocated by aper decoder for
3993 * RIC service update failure
3997 * Function : freeAperDecodingOfRicServiceUpdateFailure
3999 * Functionality: Deallocation of memory allocated by aper decoder
4000 * for RIC service update failure
4002 * @params[in] RICserviceUpdateFailure_t *ricServiceFailure;
4005 * ****************************************************************/
4007 void freeAperDecodingOfRicServiceUpdateFailure(RICserviceUpdateFailure_t *ricServiceFailure)
4011 if(ricServiceFailure)
4013 if(ricServiceFailure->protocolIEs.list.array)
4015 for(arrIdx=0; arrIdx<ricServiceFailure->protocolIEs.list.count; arrIdx++)
4017 if(ricServiceFailure->protocolIEs.list.array[arrIdx])
4019 free(ricServiceFailure->protocolIEs.list.array[arrIdx]);
4022 free(ricServiceFailure->protocolIEs.list.array);
4027 /******************************************************************
4029 * @brief Processes RIC service update failure sent by RIC
4033 * Function : procRicServiceUpdateFailure
4035 * Functionality: Processes RIC service update failure sent by RIC
4037 * @params[in] E2AP_PDU_t ASN decoded E2AP message
4038 * @return ROK - success
4041 * ****************************************************************/
4043 void procRicServiceUpdateFailure(E2AP_PDU_t *e2apMsg)
4045 uint8_t arrIdx =0, timerValue=0;
4046 RICserviceUpdateFailure_t *ricServiceFailure=NULL;
4048 DU_LOG("\nINFO --> E2AP : RIC service update failure received");
4049 ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
4051 for(arrIdx=0; arrIdx<ricServiceFailure->protocolIEs.list.count; arrIdx++)
4053 switch(ricServiceFailure->protocolIEs.list.array[arrIdx]->id)
4055 case ProtocolIE_IDE2_id_TransactionID:
4059 case ProtocolIE_IDE2_id_TimeToWaitE2:
4061 timerValue = covertE2WaitTimerEnumToValue(ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
4062 if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer), EVENT_RIC_SERVICE_UPDATE_TMR)) == FALSE)
4064 duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer), EVENT_RIC_SERVICE_UPDATE_TMR, timerValue);
4068 DU_LOG("\nERROR --> E2AP : EVENT_RIC_SERVICE_UPDATE_TMR timer is already running");
4073 case ProtocolIE_IDE2_id_CauseE2:
4080 freeAperDecodingOfRicServiceUpdateFailure(ricServiceFailure);
4083 /*******************************************************************
4085 * @brief Handles received E2AP message and sends back response
4089 * Function : E2APMsgHdlr
4092 * - Decodes received E2AP control message
4093 * - Prepares response message, encodes and sends to SCTP
4096 * @return ROK - success
4099 * ****************************************************************/
4100 void E2APMsgHdlr(Buffer *mBuf)
4103 char *recvBuf = NULLP;
4105 MsgLen recvBufLen =0;
4106 E2AP_PDU_t *e2apMsg = NULLP;
4107 asn_dec_rval_t rval ={0}; /* Decoder return value */
4108 E2AP_PDU_t e2apasnmsg={0} ;
4110 DU_LOG("\nDEBUG --> E2AP : Received E2AP message buffer");
4111 ODU_PRINT_MSG(mBuf, 0,0);
4113 /* Copy mBuf into char array to decode it */
4114 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
4115 DU_ALLOC(recvBuf, (Size)recvBufLen);
4117 if(recvBuf == NULLP)
4119 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
4122 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
4124 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
4128 #ifdef DEBUG_ASN_PRINT
4129 printf("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
4130 for(i=0; i< recvBufLen; i++)
4132 printf("%x",recvBuf[i]);
4136 /* Decoding flat buffer into E2AP messsage */
4137 e2apMsg = &e2apasnmsg;
4138 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
4140 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
4141 DU_FREE(recvBuf, (Size)recvBufLen);
4143 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
4145 DU_LOG("\nERROR --> E2AP : ASN decode failed");
4149 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4151 switch(e2apMsg->present)
4153 case E2AP_PDU_PR_unsuccessfulOutcome:
4155 switch(e2apMsg->choice.unsuccessfulOutcome->value.present)
4157 case UnsuccessfulOutcomeE2__value_PR_E2setupFailure:
4159 procE2SetupFailure(e2apMsg);
4162 case UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure:
4164 procRicServiceUpdateFailure(e2apMsg);
4169 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_unsuccessfulOutcome [%d]",\
4170 e2apMsg->choice.unsuccessfulOutcome->value.present);
4176 case E2AP_PDU_PR_successfulOutcome:
4178 switch(e2apMsg->choice.successfulOutcome->value.present)
4180 case SuccessfulOutcomeE2__value_PR_E2setupResponse:
4184 procE2SetupRsp(e2apMsg);
4188 case SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge:
4190 DU_LOG("\nDEBUG --> E2AP : E2 node Config update ack message recevied");
4193 case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
4195 procResetResponse(e2apMsg);
4198 case SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge:
4200 procRicServiceUpdateAck(e2apMsg);
4207 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_successfulOutcome [%d]",\
4208 e2apMsg->choice.successfulOutcome->value.present);
4211 }/* End of switch(successfulOutcome) */
4212 free(e2apMsg->choice.successfulOutcome);
4216 case E2AP_PDU_PR_initiatingMessage:
4218 switch(e2apMsg->choice.initiatingMessage->value.present)
4220 case InitiatingMessageE2__value_PR_RICsubscriptionRequest:
4222 procRicSubscriptionRequest(e2apMsg);
4225 case InitiatingMessageE2__value_PR_RICserviceQuery:
4227 procRicServiceQuery(e2apMsg);
4232 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\
4233 e2apMsg->choice.initiatingMessage->value.present);
4236 }/* End of switch(initiatingMessage) */
4237 free(e2apMsg->choice.initiatingMessage);
4242 DU_LOG("\nERROR --> E2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
4247 }/* End of switch(e2apMsg->present) */
4249 } /* End of E2APMsgHdlr */
4251 /**********************************************************************
4253 **********************************************************************/