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"
49 /*******************************************************************
51 * @brief Builds Global gNodeB Params
55 * Function : BuildGlobalgNBId
57 * Functionality: Building the Plmn and gNB id
59 * @params[in] GlobalE2node_gNB_ID_t *gNbId
60 * @return ROK - success
63 ******************************************************************/
65 uint8_t BuildGlobalgNBId(GlobalE2node_gNB_ID_t *gNbId)
69 uint8_t gnbId = duCb.gnbId;
72 /* fill Global gNB ID Id */
73 gNbId->global_gNB_ID.plmn_id.size = 3 * sizeof(uint8_t);
74 gNbId->global_gNB_ID.plmn_id.buf = NULLP;
75 DU_ALLOC(gNbId->global_gNB_ID.plmn_id.buf , gNbId->global_gNB_ID.plmn_id.size);
76 if(gNbId->global_gNB_ID.plmn_id.buf == NULLP)
78 DU_LOG("\nERROR --> E2AP: Memory allocation failed for Plmn buffer");
83 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
84 gNbId->global_gNB_ID.plmn_id.buf);
85 gNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID;
86 /* Allocate Buffer size */
87 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size = byteSize * sizeof(uint8_t);
88 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf = NULLP;
89 DU_ALLOC(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf, \
90 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
91 if(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf == NULLP)
93 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gnb buffer");
98 fillBitString(&gNbId->global_gNB_ID.gnb_id.choice.gnb_ID, unused, byteSize, gnbId);
103 DU_ALLOC( gNbId->gNB_DU_ID, sizeof(GNB_DU_ID_t));
104 if(gNbId->gNB_DU_ID == NULLP)
106 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gNB_DU_ID ");
111 gNbId->gNB_DU_ID->size = sizeof(uint8_t);
112 DU_ALLOC( gNbId->gNB_DU_ID->buf, sizeof(uint8_t));
113 if(gNbId->gNB_DU_ID->buf)
115 gNbId->gNB_DU_ID->buf[0] =duCb.e2apDb.e2NodeId;
119 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gNB_DU_ID buffer");
127 /******************************************************************
129 * @brief Search E2 node component with the help of action type
133 * Function : searchE2NodeComponentInfo
135 * Functionality: Search E2 node component with the help of action type
137 * @params[in] uint8_t componentActionType
140 * ****************************************************************/
142 CmLList *searchE2NodeComponentInfo(InterfaceType interfaceType, uint8_t componentActionType)
144 E2NodeComponent *e2NodeComponentInfo;
147 if(duCb.e2apDb.e2NodeComponentList.count)
149 CM_LLIST_FIRST_NODE(&duCb.e2apDb.e2NodeComponentList, node);
152 e2NodeComponentInfo = (E2NodeComponent*)node->node;
153 if((e2NodeComponentInfo->interfaceType == interfaceType) && (e2NodeComponentInfo->componentActionType == componentActionType))
162 /*******************************************************************
164 * @brief Builds E2 node config addition list
168 * Function : BuildE2NodeConfigAddList
170 * Functionality: Building E2 node config addition list
172 * @params[in] E2nodeComponentConfigAddition_List_t *e2NodeAddList
173 * @return ROK - success
176 ******************************************************************/
178 uint8_t BuildE2NodeConfigAddList(E2nodeComponentConfigAddition_List_t *e2NodeAddList)
182 E2NodeComponent *e2NodeComponentInfo;
183 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItemIe;
184 E2nodeComponentConfigAddition_Item_t *e2NodeAddItem;
186 e2NodeAddList->list.count = 1;
187 e2NodeAddList->list.size = e2NodeAddList->list.count * sizeof(E2nodeComponentConfigAddition_ItemIEs_t *);
188 DU_ALLOC(e2NodeAddList->list.array, e2NodeAddList->list.size);
189 if(e2NodeAddList->list.array == NULLP)
191 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
195 for(arrIdx = 0; arrIdx< e2NodeAddList->list.count; arrIdx++)
197 DU_ALLOC(e2NodeAddList->list.array[arrIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
198 if(e2NodeAddList->list.array[arrIdx] == NULLP)
200 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
205 node = searchE2NodeComponentInfo(F1, E2_NODE_COMPONENT_ADD);
208 DU_LOG("\nERROR --> E2AP : Received e2NodeComponentInfo is null");
211 e2NodeComponentInfo = (E2NodeComponent*)node->node;
214 e2NodeAddItemIe = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[arrIdx];
215 e2NodeAddItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition_Item;
216 e2NodeAddItemIe->criticality = CriticalityE2_reject;
217 e2NodeAddItemIe->value.present = E2nodeComponentConfigAddition_ItemIEs__value_PR_E2nodeComponentConfigAddition_Item;
218 e2NodeAddItem = &e2NodeAddItemIe->value.choice.E2nodeComponentConfigAddition_Item;
220 /* E2nodeComponentInterfaceType */
221 e2NodeAddItem->e2nodeComponentInterfaceType = E2nodeComponentInterfaceType_f1;
223 /* E2 Node Component Request Part */
224 if(e2NodeComponentInfo->componentRequestPart)
226 e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.size = e2NodeComponentInfo->reqBufSize ;
227 DU_ALLOC(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf,\
228 e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.size);
229 if(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf == NULLP)
231 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
235 memcpy(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf,\
236 e2NodeComponentInfo->componentRequestPart, e2NodeAddItem->e2nodeComponentConfiguration.\
237 e2nodeComponentRequestPart.size);
241 DU_LOG("\nERROR --> E2AP: componentRequestPart is null ");
246 /* E2 Node Component Response Part */
247 if(e2NodeComponentInfo->componentResponsePart)
249 e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.size = e2NodeComponentInfo->rspBufSize;
250 DU_ALLOC(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.buf, \
251 e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.size);
252 if(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.buf == NULLP)
254 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
257 memcpy(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.buf, \
258 e2NodeComponentInfo->componentResponsePart, e2NodeAddItem->e2nodeComponentConfiguration.\
259 e2nodeComponentResponsePart.size);
263 DU_LOG("\nERROR --> E2AP: componentResponsePart is null");
267 /* E2 Node Component ID */
268 e2NodeAddItem->e2nodeComponentID.present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
269 DU_ALLOC(e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
270 sizeof(E2nodeComponentInterfaceF1_t));
271 if(e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1 == NULLP)
273 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
276 e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
277 DU_ALLOC(e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
278 e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
280 if(e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
282 DU_LOG("\nERROR -->list. E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
285 e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[arrIdx] = e2NodeComponentInfo->componentId;
290 /*******************************************************************
292 * @brief deallocation of E2SM_KPM_RANfunction_Description_t
296 * Function : freeE2smKpmRanFunctionDefinition
298 * Functionality: deallocation of E2SM_KPM_RANfunction_Description_t
300 * @params[in] E2SM_KPM_RANfunction_Description_t *ranFunctionDefinition
303 ******************************************************************/
305 void freeE2smKpmRanFunctionDefinition(E2SM_KPM_RANfunction_Description_t *ranFunctionDefinition)
307 MeasurementInfo_Action_Item_t *measInfoList;
308 uint8_t eventTriggerIdx, reportStyleIdx, measInfoIdx;
309 RANfunction_Name_t *ranFuncName;
310 struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle;
311 struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List *eventTriggerStyle;
312 if(ranFunctionDefinition)
314 ranFuncName = &ranFunctionDefinition->ranFunction_Name;
315 /* Free RAN function Name */
316 DU_FREE(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size);
317 DU_FREE(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size);
318 DU_FREE(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size);
320 /* Sequence of Event Trigger styles */
321 eventTriggerStyle = ranFunctionDefinition->ric_EventTriggerStyle_List;
322 if(eventTriggerStyle)
324 if(eventTriggerStyle->list.array)
326 for(eventTriggerIdx =0;eventTriggerIdx<eventTriggerStyle->list.count; eventTriggerIdx++)
328 if(eventTriggerStyle->list.array[eventTriggerIdx])
330 DU_FREE(eventTriggerStyle->list.array[eventTriggerIdx]->ric_EventTriggerStyle_Name.buf,\
331 eventTriggerStyle->list.array[eventTriggerIdx]->ric_EventTriggerStyle_Name.size);
332 DU_FREE(eventTriggerStyle->list.array[eventTriggerIdx], sizeof(RIC_EventTriggerStyle_Item_t ));
335 DU_FREE(eventTriggerStyle->list.array, eventTriggerStyle->list.size)
337 DU_FREE(eventTriggerStyle, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List));
340 /* Sequence of Report styles */
341 ricReportStyle = ranFunctionDefinition->ric_ReportStyle_List;
344 if(ricReportStyle->list.array)
346 for(reportStyleIdx =0;reportStyleIdx<ricReportStyle->list.count; reportStyleIdx++)
348 if(ricReportStyle->list.array[reportStyleIdx])
350 if(ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.buf)
352 DU_FREE(ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.buf,\
353 ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.size);
355 if(ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.array)
357 for(measInfoIdx=0; measInfoIdx<ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.count; \
360 measInfoList = ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.array[measInfoIdx];
363 DU_FREE(measInfoList->measID, sizeof(long));
364 DU_FREE(measInfoList->measName.buf, measInfoList->measName.size);
365 DU_FREE(measInfoList,sizeof(MeasurementInfo_Action_Item_t));
368 DU_FREE(measInfoList,ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.size);
370 DU_FREE(ricReportStyle->list.array[reportStyleIdx], sizeof(RIC_ReportStyle_Item_t));
373 DU_FREE(ricReportStyle->list.array, ricReportStyle->list.size);
375 DU_FREE(ricReportStyle, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List));
377 DU_FREE(ranFunctionDefinition, sizeof(E2SM_KPM_RANfunction_Description_t));
381 /*******************************************************************
383 * @brief fill the e2sm ric report style
387 * Function : fillRicReportStyle
389 * Functionality: fill the report style
391 * @params[in] RanFunction *ranFuncDb, struct
392 * E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle
393 * @return ROK - success
396 ******************************************************************/
397 uint8_t fillRicReportStyle(RanFunction *ranFuncDb, struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle)
399 uint8_t styleIdx, measInfoIdx;
400 MeasurementInfo_Action_List_t *measInfo;
403 ricReportStyle->list.count = ranFuncDb->numOfReportStyleSupported;
404 ricReportStyle->list.size = ricReportStyle->list.count * sizeof(RIC_ReportStyle_Item_t*);
405 DU_ALLOC(ricReportStyle->list.array, ricReportStyle->list.size);
406 if(!ricReportStyle->list.array)
408 DU_LOG("\nERROR --> E2AP: Memory allocation failed for ranFuncDefinition %d",__LINE__);
412 for(styleIdx =0;styleIdx<ricReportStyle->list.count; styleIdx++)
414 DU_ALLOC(ricReportStyle->list.array[styleIdx], sizeof(RIC_ReportStyle_Item_t));
415 if(!ricReportStyle->list.array[styleIdx])
417 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
421 /* RIC Report Style Type */
422 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Type = ranFuncDb->reportStyleList[styleIdx].reportStyle.styleType;
424 /* RIC Report Style Format Type */
425 ricReportStyle->list.array[styleIdx]->ric_ActionFormat_Type = ranFuncDb->reportStyleList[styleIdx].reportStyle.formatType;
427 /* RIC Report Style Name */
428 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size = strlen(ranFuncDb->reportStyleList[styleIdx].reportStyle.name);
429 DU_ALLOC(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf,\
430 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size);
431 if(!ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf)
433 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
436 memcpy(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf, ranFuncDb->reportStyleList[styleIdx].reportStyle.name,\
437 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size);
439 /* RIC Indication Header Format Type*/
440 ricReportStyle->list.array[styleIdx]->ric_IndicationHeaderFormat_Type = ranFuncDb->ricIndicationHeaderFormat;
442 /* RIC Indication Message Format Type*/
443 ricReportStyle->list.array[styleIdx]->ric_IndicationMessageFormat_Type = ranFuncDb->ricIndicationMessageFormat;
445 /* Measurement Info Action List */
446 CmLListCp measInfoList =ranFuncDb->reportStyleList[styleIdx].measurementInfoList;
447 if(!measInfoList.count)
452 CM_LLIST_FIRST_NODE(&ranFuncDb->reportStyleList[styleIdx].measurementInfoList, node);
453 measInfo = &ricReportStyle->list.array[styleIdx]->measInfo_Action_List;
455 measInfo->list.count = measInfoList.count;
456 measInfo->list.size = measInfoList.count*sizeof(MeasurementInfo_Action_Item_t*);
457 DU_ALLOC(measInfo->list.array, measInfo->list.size);
458 if(!measInfo->list.array)
460 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
464 for(measInfoIdx=0; measInfoIdx<measInfo->list.count; measInfoIdx++)
468 DU_LOG("\nERROR --> E2AP: Measurement info node is null");
472 DU_ALLOC(measInfo->list.array[measInfoIdx],sizeof(MeasurementInfo_Action_Item_t));
473 if(!measInfo->list.array[measInfoIdx])
475 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
478 MeasurementInfoForAction *measInfoForAction= (MeasurementInfoForAction*)node->node;
479 DU_ALLOC(measInfo->list.array[measInfoIdx]->measID, sizeof(long));
480 if(!measInfo->list.array[measInfoIdx]->measID)
482 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
486 memcpy(measInfo->list.array[measInfoIdx]->measID, &measInfoForAction->measurementTypeId,sizeof(long));
487 measInfo->list.array[measInfoIdx]->measName.size= strlen(measInfoForAction->measurementTypeName);
488 DU_ALLOC(measInfo->list.array[measInfoIdx]->measName.buf, measInfo->list.array[measInfoIdx]->measName.size);
489 if(!measInfo->list.array[measInfoIdx]->measName.size)
491 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
495 memcpy(measInfo->list.array[measInfoIdx]->measName.buf, \
496 measInfoForAction->measurementTypeName,\
497 measInfo->list.array[measInfoIdx]->measName.size);
504 /*******************************************************************
506 * @brief fill the ric event trigger style
510 * Function : fillRicEventTriggerStyle
512 * Functionality: fill the ric event trigger style
515 * @return ROK - success
518 ******************************************************************/
519 uint8_t fillRicEventTriggerStyle(RanFunction *ranFuncDb, struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List *ricEventTriggerStyle)
523 ricEventTriggerStyle->list.count = ranFuncDb->numOfEventTriggerStyleSupported;
524 ricEventTriggerStyle->list.size = ricEventTriggerStyle->list.count* sizeof(RIC_EventTriggerStyle_Item_t *);
525 DU_ALLOC(ricEventTriggerStyle->list.array, ricEventTriggerStyle->list.size);
526 if(!ricEventTriggerStyle->list.array)
528 DU_LOG("\nERROR --> E2AP: Memory allocation failed for ric_EventTriggerStyle_List %d",__LINE__);
532 for(styleIdx =0;styleIdx<ricEventTriggerStyle->list.count; styleIdx++)
534 DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx], sizeof(RIC_EventTriggerStyle_Item_t ));
535 if(!ricEventTriggerStyle->list.array[styleIdx])
537 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
540 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Type = ranFuncDb->eventTriggerStyleList[styleIdx].styleType;
542 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerFormat_Type = ranFuncDb->eventTriggerStyleList[styleIdx].formatType;
544 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size = strlen(ranFuncDb->eventTriggerStyleList[styleIdx].name);
545 DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,\
546 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size);
547 if(!ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf)
549 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
552 memcpy(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,ranFuncDb->eventTriggerStyleList[styleIdx].name,\
553 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size);
559 /*******************************************************************
561 * @brief Builds Ran function item
565 * Function : BuildRanFunctionItem
567 * Functionality: Building RAN function item
570 * RAN function item that has to be filled
571 * Stored RAN Function information
572 * @return ROK - success
575 ******************************************************************/
577 uint8_t BuildRanFunctionItem(RANfunction_Item_t *ranFuncItem, RanFunction *ranFuncDb)
579 uint8_t ret =RFAILED;
580 RANfunctionDefinition_t *ranFunctionDefinition;
581 RANfunction_Name_t *ranFuncName;
582 asn_enc_rval_t encRetVal;
583 E2SM_KPM_RANfunction_Description_t *ranFuncDefinition;
588 ranFuncItem->ranFunctionID = ranFuncDb->id;
590 /* RAN Function Revision*/
591 ranFuncItem->ranFunctionRevision = ranFuncDb->revisionCounter;
593 /* RAN function OID*/
594 ranFuncItem->ranFunctionOID.size = strlen(ranFuncDb->name.serviceModelOID);
595 DU_ALLOC(ranFuncItem->ranFunctionOID.buf, ranFuncItem->ranFunctionOID.size);
596 if(!ranFuncItem->ranFunctionOID.buf)
598 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
601 memcpy(ranFuncItem->ranFunctionOID.buf, ranFuncDb->name.serviceModelOID, ranFuncItem->ranFunctionOID.size);
603 /* RAN function Definition */
604 DU_ALLOC(ranFuncDefinition, sizeof(E2SM_KPM_RANfunction_Description_t));
605 if(!ranFuncDefinition)
607 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
611 /* RAN function Name */
612 ranFuncName = &ranFuncDefinition->ranFunction_Name;
614 /* RAN function ShortName */
615 ranFuncName->ranFunction_ShortName.size = strlen(ranFuncDb->name.shortName);
616 DU_ALLOC(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size);
617 if(!ranFuncName->ranFunction_ShortName.buf)
619 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
622 memcpy(ranFuncName->ranFunction_ShortName.buf, ranFuncDb->name.shortName, strlen(ranFuncDb->name.shortName));
624 /* RAN function E2SM_OID */
625 ranFuncName->ranFunction_E2SM_OID.size = strlen(ranFuncDb->name.serviceModelOID);
626 DU_ALLOC(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size);
627 if(!ranFuncName->ranFunction_E2SM_OID.buf)
629 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
632 memcpy(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncDb->name.serviceModelOID, ranFuncName->ranFunction_E2SM_OID.size);
634 /* RAN Function Name Description */
635 ranFuncName->ranFunction_Description.size = strlen(ranFuncDb->name.description);
636 DU_ALLOC(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size);
637 if(!ranFuncName->ranFunction_Description.buf)
639 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
642 memcpy(ranFuncName->ranFunction_Description.buf, ranFuncDb->name.description, ranFuncName->ranFunction_Description.size);
644 /* RIC Event Trigger Style List */
645 DU_ALLOC(ranFuncDefinition->ric_EventTriggerStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List));
646 if(!ranFuncDefinition->ric_EventTriggerStyle_List)
648 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
652 if(fillRicEventTriggerStyle(ranFuncDb, ranFuncDefinition->ric_EventTriggerStyle_List)!=ROK)
654 DU_LOG("\nERROR --> E2AP: failed to fill ric event trigger style");
658 /* RIC Report Style List */
659 DU_ALLOC(ranFuncDefinition->ric_ReportStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List));
660 if(!ranFuncDefinition->ric_ReportStyle_List)
662 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
665 if(fillRicReportStyle(ranFuncDb, ranFuncDefinition->ric_ReportStyle_List) != ROK)
667 DU_LOG("\nERROR --> E2AP: failed to fill ric report style");
671 /* Encode the F1SetupRequest type as APER */
672 xer_fprint(stdout, &asn_DEF_E2SM_KPM_RANfunction_Description, ranFuncDefinition);
674 memset(encBuf, 0, ENC_BUF_MAX_LEN);
676 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_RANfunction_Description, 0, ranFuncDefinition, PrepFinalEncBuf, encBuf);
679 if(encRetVal.encoded == ENCODE_FAIL)
681 DU_LOG("\nERROR --> F1AP : Could not encode RAN function definition (at %s)\n",\
682 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
687 DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RAN function definition \n");
688 for(uint8_t measIeIdx=0; measIeIdx< encBufSize; measIeIdx++)
690 printf("%x",encBuf[measIeIdx]);
692 ranFunctionDefinition = &ranFuncItem->ranFunctionDefinition;
693 ranFunctionDefinition->size = encBufSize;
694 DU_ALLOC(ranFunctionDefinition->buf, encBufSize);
695 if(ranFunctionDefinition->buf == NULLP)
697 DU_LOG("\nERROR --> F1AP : Memory allocation failed for RAN function definition buffer");
700 memcpy(ranFunctionDefinition->buf, &encBuf, encBufSize);
705 freeE2smKpmRanFunctionDefinition(ranFuncDefinition);
709 /*******************************************************************
711 * @brief Builds Ran function add list based on the procedure code
715 * Function : BuildRanFunctionAddList
717 * Functionality: Building RAN addition addition list
718 * In case of ProcedureCodeE2_id_E2setup we add all the RAN Function list
719 * which is present in E2 database.
720 * In the case of other procedures, we just fill the RAN functions whose ID
721 * is contained in recvList
726 * Count of ran functions to be added in the list
727 * Received list of RAN functions
729 * @return ROK - success
732 ******************************************************************/
734 uint8_t BuildRanFunctionAddList(RANfunctions_List_t *ranFunctionsList, uint8_t procedureCode, uint8_t count, uint8_t *recvList)
737 RanFunction *ranFuncDb;
739 RANfunction_ItemIEs_t *ranFuncItemIe;
741 /* For ProcedureCodeE2_id_E2setup, the number of RAN function list items is
742 * equal to the number of ran function entries stored in the database.
743 * For any other procedure, the RAN function list count is equal
744 * to the count of ran functions obtained from the function's caller */
746 if(procedureCode == ProcedureCodeE2_id_E2setup)
747 ranFunctionsList->list.count = duCb.e2apDb.numOfRanFunction;
749 ranFunctionsList->list.count = count;
751 ranFunctionsList->list.size = ranFunctionsList->list.count * sizeof(RANfunction_ItemIEs_t*);
752 DU_ALLOC(ranFunctionsList->list.array, ranFunctionsList->list.size);
753 if(ranFunctionsList->list.array == NULLP)
755 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
759 for(ranFuncIdx = 0; ranFuncIdx< ranFunctionsList->list.count; ranFuncIdx++)
761 DU_ALLOC(ranFunctionsList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
762 if(ranFunctionsList->list.array[ranFuncIdx] == NULLP)
764 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
767 if(procedureCode == ProcedureCodeE2_id_E2setup)
769 /* Getting all of the RAN function's information from DuCb one by one*/
770 ranFuncDb = &duCb.e2apDb.ranFunction[ranFuncIdx];
774 /* Getting only the RAN function information from DuCb whose Id is
775 * present in the received array */
776 id =recvList[ranFuncIdx];
777 ranFuncDb = &duCb.e2apDb.ranFunction[id-1];
779 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
780 ranFuncItemIe->id = ProtocolIE_IDE2_id_RANfunction_Item;
781 ranFuncItemIe->criticality = CriticalityE2_ignore;
782 ranFuncItemIe->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item;
783 BuildRanFunctionItem(&ranFuncItemIe->value.choice.RANfunction_Item, ranFuncDb);
788 /*******************************************************************
790 * @brief De Allocate E2 Setup Request Message
794 * Function : FreeE2SetupReq
796 * Functionality: De-Allocating E2 Setup request Message
798 * @params[in] E2AP_PDU_t *e2apMsg
802 * ****************************************************************/
804 void FreeE2SetupReq(E2AP_PDU_t *e2apMsg)
807 uint8_t e2NodeAddListIdx =0, ranFuncAddListIdx;
808 E2setupRequest_t *e2SetupReq;
809 E2nodeComponentConfigAddition_List_t *e2NodeAddList;
810 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem;
811 RANfunctions_List_t *ranFunctionsList;
812 RANfunction_ItemIEs_t *ranFuncItemIe;
813 RANfunction_Item_t *ranFunItem;
815 /* De-allocating Memory */
818 if(e2apMsg->choice.initiatingMessage != NULLP)
820 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
821 if(e2SetupReq->protocolIEs.list.array != NULLP)
823 for(arrIdx = 0; arrIdx < e2SetupReq->protocolIEs.list.count; arrIdx++)
825 if(e2SetupReq->protocolIEs.list.array[arrIdx] != NULLP)
827 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
829 case ProtocolIE_IDE2_id_TransactionID:
831 case ProtocolIE_IDE2_id_GlobalE2node_ID:
833 if(e2SetupReq->protocolIEs.list.array[arrIdx]->\
834 value.choice.GlobalE2node_ID.choice.gNB != NULLP)
836 GlobalE2node_gNB_ID_t *gNbId = NULLP;
837 gNbId = e2SetupReq->protocolIEs.list.array[arrIdx]->\
838 value.choice.GlobalE2node_ID.choice.gNB;
839 if(gNbId->global_gNB_ID.plmn_id.buf != NULLP)
841 DU_FREE(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf,\
842 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
843 DU_FREE(gNbId->global_gNB_ID.plmn_id.buf,\
844 gNbId->global_gNB_ID.plmn_id.size);
847 if(gNbId->gNB_DU_ID != NULLP)
849 DU_FREE( gNbId->gNB_DU_ID->buf, gNbId->gNB_DU_ID->size);
850 DU_FREE(gNbId->gNB_DU_ID, sizeof(GNB_DU_ID_t));
852 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
853 choice.GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
857 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
859 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
860 if(e2NodeAddList->list.array)
862 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
864 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
866 /* Free E2 Node Component Request Part */
867 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf,\
868 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.size);
870 /* Free E2 Node Component Response Part */
871 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.\
872 e2nodeComponentResponsePart.buf, \
873 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentResponsePart.size);
875 /* Free E2 Node Component ID */
876 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1)
878 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
879 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
880 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
881 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
882 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
883 sizeof(E2nodeComponentInterfaceF1_t));
885 DU_FREE(e2NodeAddList->list.array[e2NodeAddListIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
887 DU_FREE(e2NodeAddList->list.array, e2NodeAddList->list.size);
891 case ProtocolIE_IDE2_id_RANfunctionsAdded:
893 ranFunctionsList = &(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List);
894 if(ranFunctionsList->list.array)
896 for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++)
898 if(ranFunctionsList->list.array[ranFuncAddListIdx])
900 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx];
901 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
902 DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size);
903 DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size);
904 DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t));
907 DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size);
913 DU_LOG("\nERROR --> E2AP: Invalid event at e2SetupRequet %ld ",\
914 (e2SetupReq->protocolIEs.list.array[arrIdx]->id));
917 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx], sizeof(E2setupRequestIEs_t));
920 DU_FREE(e2SetupReq->protocolIEs.list.array, e2SetupReq->protocolIEs.list.size);
922 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
924 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
928 /*******************************************************************
930 * @brief Builds and Send the E2SetupRequest
934 * Function : BuildAndSendE2SetupReq
936 * Functionality:Fills the E2SetupRequest
938 * @return ROK - success
941 ******************************************************************/
943 uint8_t BuildAndSendE2SetupReq()
945 uint8_t arrIdx = 0, elementCnt=0;
946 uint8_t transId = 0, ret = ROK;
948 E2AP_PDU_t *e2apMsg = NULLP;
949 E2setupRequest_t *e2SetupReq = NULLP;
950 asn_enc_rval_t encRetVal; /* Encoder return value */
952 DU_LOG("\nINFO --> E2AP : Building E2 Setup Request\n");
955 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
958 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
961 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
962 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
963 if(e2apMsg->choice.initiatingMessage == NULLP)
965 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
968 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
969 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2setup;
970 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2setupRequest;
971 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
974 e2SetupReq->protocolIEs.list.count = elementCnt;
975 e2SetupReq->protocolIEs.list.size = elementCnt * sizeof(E2setupRequestIEs_t*);
977 /* Initialize the E2Setup members */
978 DU_ALLOC(e2SetupReq->protocolIEs.list.array, \
979 e2SetupReq->protocolIEs.list.size);
980 if(e2SetupReq->protocolIEs.list.array == NULLP)
982 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
985 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
987 DU_ALLOC(e2SetupReq->protocolIEs.list.array[arrIdx],\
988 sizeof(E2setupRequestIEs_t));
989 if(e2SetupReq->protocolIEs.list.array[arrIdx] == NULLP)
991 memAllocFailed = true;
992 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayarrIdx [%d]", arrIdx);
996 if(memAllocFailed == true)
1002 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1003 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1004 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
1005 transId = assignTransactionId();
1006 e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
1009 /* GlobalE2node_gNB_ID */
1010 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_GlobalE2node_ID;
1011 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1012 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID;
1013 e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB;
1015 DU_ALLOC(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
1016 GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
1017 if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
1018 GlobalE2node_ID.choice.gNB == NULLP)
1020 DU_LOG("\nERROR --> E2AP : Memory allocation failed for gNbId");
1025 ret = BuildGlobalgNBId(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
1026 choice.GlobalE2node_ID.choice.gNB);
1029 DU_LOG("\nERROR --> E2AP : Failed to build Global Gnb Id");
1034 /* RAN Functions Added List */
1036 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded;
1037 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1038 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_RANfunctions_List;
1039 if(BuildRanFunctionAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List), ProcedureCodeE2_id_E2setup, 0, NULL)!=ROK)
1041 DU_LOG("\nERROR --> E2AP : Failed to create RAN Function");
1045 /* E2 Node Component Configuration Addition List */
1047 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition;
1048 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1049 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_E2nodeComponentConfigAddition_List;
1050 if(BuildE2NodeConfigAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List))!=ROK)
1052 DU_LOG("\nERROR --> E2AP : Failed to create E2 Node config list");
1058 /* Prints the Msg formed */
1059 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1061 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1063 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1065 if(encRetVal.encoded == ENCODE_FAIL)
1067 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\
1068 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1073 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n");
1074 #ifdef DEBUG_ASN_PRINT
1075 for(int i=0; i< encBufSize; i++)
1077 printf("%x",encBuf[i]);
1081 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
1083 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
1088 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
1089 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
1091 FreeE2SetupReq(e2apMsg);
1093 }/* End of BuildAndSendE2SetupReq */
1095 /*******************************************************************
1097 * @brief Builds Ric Request Id
1101 * Function : BuildRicRequestId
1103 * Functionality: Building the Ric Request Id
1105 * @params[in] RICrequestID_t *ricReqId
1106 * @return ROK - success
1109 * ****************************************************************/
1111 uint8_t BuildRicRequestId(RICrequestID_t *ricReqId)
1113 if(ricReqId == NULLP)
1118 ricReqId->ricRequestorID = 1;
1119 ricReqId->ricInstanceID = 1;
1123 /*******************************************************************
1125 * @brief Fills the mandatory RicAdmitted List Items
1129 * Function : fillRicAdmitList
1131 * Functionality: Fills the mandatory Ric Admitted List Items
1133 * @params[in] RICaction_Admitted_ItemIEs_t *ricAdmitItems
1134 * @return ROK - success
1137 * ****************************************************************/
1139 uint8_t fillRicAdmitList(RICaction_Admitted_ItemIEs_t *ricAdmitItems)
1142 if(ricAdmitItems != NULLP)
1144 ricAdmitItems->id = ProtocolIE_IDE2_id_RICaction_Admitted_Item;
1145 ricAdmitItems->criticality = CriticalityE2_reject;
1146 ricAdmitItems->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
1147 ricAdmitItems->value.choice.RICaction_Admitted_Item.ricActionID = 1;
1155 /*******************************************************************
1157 * @brief Builds the mandatory RicAdmitted List Params
1161 * Function : BuildRicAdmitList
1163 * Functionality: Builds the mandatory Ric Admitted List Params
1165 * @params[in] RICaction_Admitted_List_t *admitListPtr
1166 * @return ROK - success
1169 * ****************************************************************/
1171 uint8_t BuildRicAdmitList(RICaction_Admitted_List_t *admitListPtr)
1178 if(admitListPtr == NULLP)
1180 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC Admit List failed");
1185 admitListPtr->list.count = elementCnt;
1186 admitListPtr->list.size = elementCnt * sizeof(RICaction_Admitted_ItemIEs_t);
1187 DU_ALLOC(admitListPtr->list.array, admitListPtr->list.size);
1188 if(admitListPtr->list.array == NULLP)
1190 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC Admit List failed");
1195 for(idx=0 ; idx<elementCnt ; idx++ )
1197 DU_ALLOC(admitListPtr->list.array[idx], sizeof(RICaction_Admitted_ItemIEs_t));
1198 if(admitListPtr->list.array[idx] == NULLP)
1206 fillRicAdmitList((RICaction_Admitted_ItemIEs_t *)admitListPtr->list.array[idx]);
1212 /*******************************************************************
1214 * @breif Deallocation of BuildAndSendRicSubscriptionRsp memory
1218 * Function : FreeRicSubscriptionRsp
1220 * Functionality:Free the RicSubscriptionRsp
1222 * @param[in] E2AP_PDU_t *e2apRicMsg
1227 ******************************************************************/
1228 void FreeRicSubscriptionRsp(E2AP_PDU_t *e2apRicMsg)
1230 RICsubscriptionResponse_t *ricSubscriptionRsp= NULLP;
1233 RICaction_Admitted_List_t *admitListPtr;
1235 if(e2apRicMsg != NULLP)
1237 if(e2apRicMsg->choice.successfulOutcome != NULLP)
1239 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
1240 if(ricSubscriptionRsp)
1242 if(ricSubscriptionRsp->protocolIEs.list.array != NULLP)
1244 for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
1246 if(ricSubscriptionRsp->protocolIEs.list.array[idx] != NULLP)
1248 switch(ricSubscriptionRsp->protocolIEs.list.array[idx]->id)
1250 case ProtocolIE_IDE2_id_RICrequestID:
1253 case ProtocolIE_IDE2_id_RANfunctionID:
1256 case ProtocolIE_IDE2_id_RICactions_Admitted:
1258 admitListPtr = &ricSubscriptionRsp->protocolIEs.list.\
1259 array[idx]->value.choice.RICaction_Admitted_List;
1260 if(admitListPtr->list.array != NULLP)
1262 for(idx1=0 ; idx1<admitListPtr->list.count; idx1++ )
1264 if(admitListPtr->list.array[idx1] != NULLP)
1266 DU_FREE(admitListPtr->list.array[idx1],
1267 sizeof(RICaction_Admitted_ItemIEs_t));
1270 DU_FREE(admitListPtr->list.array, admitListPtr->list.size);
1277 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array[idx], \
1278 sizeof(RICsubscriptionResponse_IEs_t));
1281 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array, \
1282 ricSubscriptionRsp->protocolIEs.list.size);
1285 DU_FREE(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1287 DU_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
1290 /*******************************************************************
1292 * @brief Builds and Send the RicSubscriptionRsp
1296 * Function : BuildAndSendRicSubscriptionRsp
1298 * functionality:Fills the RicSubscriptionRsp
1300 * @return ROK - success
1303 ******************************************************************/
1304 uint8_t FillRicSubscriptionRsp(RICsubscriptionResponse_t *ricSubscriptionRsp )
1308 uint8_t elementCnt = 0;
1309 uint8_t BuildRicRequestIdret=ROK;
1310 uint8_t BuildRicAdmitListret=ROK;
1313 ricSubscriptionRsp->protocolIEs.list.count = elementCnt;
1314 ricSubscriptionRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionResponse_IEs_t);
1315 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array, \
1316 ricSubscriptionRsp->protocolIEs.list.size);
1317 if(ricSubscriptionRsp->protocolIEs.list.array == NULLP)
1319 DU_LOG("\nERROR --> E2AP : Memory allocation for FillRicSubscriptionRsp failed");
1324 for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
1326 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array[idx], \
1327 sizeof(RICsubscriptionResponse_IEs_t));
1328 if(ricSubscriptionRsp->protocolIEs.list.array[idx] == NULLP)
1337 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
1338 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1339 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
1340 RICsubscriptionRequest_IEs__value_PR_RICrequestID;
1341 BuildRicRequestIdret =
1342 BuildRicRequestId(&ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RICrequestID);
1343 if(BuildRicRequestIdret != ROK)
1350 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
1351 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1352 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
1353 RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
1354 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionID = 1;
1357 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactions_Admitted;
1358 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1359 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
1360 RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
1361 BuildRicAdmitListret =
1362 BuildRicAdmitList(&ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RICaction_Admitted_List);
1363 if(BuildRicAdmitListret != ROK)
1372 /*******************************************************************
1374 * @brief Builds and Send the RicSubscriptionRsp
1378 * Function : BuildAndSendRicSubscriptionRsp
1380 * Functionality:Fills the RicSubscriptionRsp
1382 * @return ROK - success
1385 ******************************************************************/
1387 uint8_t BuildAndSendRicSubscriptionRsp()
1390 E2AP_PDU_t *e2apRicMsg = NULLP;
1391 RICsubscriptionResponse_t *ricSubscriptionRsp=NULLP;
1392 asn_enc_rval_t encRetVal;
1393 uint8_t ret = RFAILED;
1394 uint8_t FillRicricSubscriptionRspret;
1398 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Response\n");
1400 DU_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
1401 if(e2apRicMsg == NULLP)
1403 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1406 e2apRicMsg->present = E2AP_PDU_PR_successfulOutcome;
1407 DU_ALLOC(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1408 if(e2apRicMsg->choice.successfulOutcome == NULLP)
1410 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC subscription Response failed");
1414 e2apRicMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
1415 e2apRicMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
1416 e2apRicMsg->choice.successfulOutcome->value.present = \
1417 SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse;
1418 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
1420 FillRicricSubscriptionRspret = FillRicSubscriptionRsp(ricSubscriptionRsp);
1421 if(FillRicricSubscriptionRspret != ROK)
1423 DU_LOG("\nERROR --> E2AP : Memory allocation for RICsubscriptionResponseIE failed");
1427 /* Prints the Msg formed */
1428 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
1430 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1432 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf,\
1434 if(encRetVal.encoded == ENCODE_FAIL)
1436 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
1437 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1442 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription response \n");
1443 #ifdef DEBUG_ASN_PRINT
1444 for(int i=0; i< encBufSize; i++)
1446 printf("%x",encBuf[i]);
1451 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
1453 DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Response failed");
1461 FreeRicSubscriptionRsp(e2apRicMsg);
1466 /******************************************************************
1468 * @brief Deallocation of memory allocated bu aper decoder for e2 setup response
1472 * Function : freeAperDecodingOfE2SetupRsp
1474 * Functionality: Deallocation of memory allocated bu aper decoder for e2
1477 * @params[in] E2setupResponse_t *e2SetRspMsg;
1480 * ****************************************************************/
1481 void freeAperDecodingOfE2SetupRsp(E2setupResponse_t *e2SetRspMsg)
1483 uint8_t arrIdx, e2NodeConfigAddAckListIdx;
1484 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem;
1485 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAddAckList;
1489 if(e2SetRspMsg->protocolIEs.list.array)
1491 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
1493 if(e2SetRspMsg->protocolIEs.list.array[arrIdx])
1495 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
1497 case ProtocolIE_IDE2_id_TransactionID:
1500 case ProtocolIE_IDE2_id_GlobalRIC_ID:
1502 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.pLMN_Identity.buf);
1503 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID.buf);
1507 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
1509 e2NodeConfigAddAckList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
1510 if(e2NodeConfigAddAckList->list.array )
1512 for(e2NodeConfigAddAckListIdx = 0; e2NodeConfigAddAckListIdx< e2NodeConfigAddAckList->list.count; e2NodeConfigAddAckListIdx++)
1514 if(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx])
1516 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx];
1517 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
1518 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf);
1519 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
1520 e2nodeComponentInterfaceTypeF1);
1521 free(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx]);
1524 free(e2NodeConfigAddAckList->list.array);
1529 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]);
1532 free(e2SetRspMsg->protocolIEs.list.array);
1536 /******************************************************************
1538 * @brief Processes E2 Setup Response sent by RIC
1542 * Function : procE2SetupRsp
1544 * Functionality: Processes E2 Setup Response sent by RIC
1546 * @params[in] E2AP_PDU_t ASN decoded E2AP message
1547 * @return ROK - success
1550 * ****************************************************************/
1551 uint8_t procE2SetupRsp(E2AP_PDU_t *e2apMsg)
1553 uint8_t arrIdx =0, transId=0;
1554 uint32_t recvBufLen;
1555 E2setupResponse_t *e2SetRspMsg;
1557 E2NodeComponent *e2NodeComponentInfo;
1559 DU_LOG("\nINFO --> E2AP : E2 Setup Response received");
1560 duCb.e2Status = TRUE; //Set E2 status as true
1561 e2SetRspMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
1563 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
1565 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
1567 case ProtocolIE_IDE2_id_TransactionID:
1569 transId = e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
1570 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
1571 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
1573 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
1577 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
1583 case ProtocolIE_IDE2_id_GlobalRIC_ID:
1585 /* To store the Ric Id Params */
1586 recvBufLen = sizeof(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value\
1587 .choice.GlobalRIC_ID.pLMN_Identity.size);
1588 memcpy(&duCb.e2apDb.ricId.plmnId, e2SetRspMsg->protocolIEs.list.array[arrIdx]\
1589 ->value.choice.GlobalRIC_ID.pLMN_Identity.buf, recvBufLen);
1590 bitStringToInt(&e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID, &duCb.e2apDb.ricId);
1591 /*TODO : duCb.e2apDb.ricId.plmnId memory to be deallocated after the usage */
1595 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
1599 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2SetupRsp:%ld",
1600 e2SetRspMsg->protocolIEs.list.array[arrIdx]->id);
1604 freeAperDecodingOfE2SetupRsp(e2SetRspMsg);
1606 node = searchE2NodeComponentInfo(F1, E2_NODE_COMPONENT_ADD);
1609 DU_LOG("\nERROR --> E2AP : Received e2NodeComponentInfo is null");
1614 e2NodeComponentInfo = (E2NodeComponent*)node->node;
1615 cmLListDelFrm(&duCb.e2apDb.e2NodeComponentList, node);
1616 DU_FREE(e2NodeComponentInfo->componentRequestPart, e2NodeComponentInfo->reqBufSize);
1617 DU_FREE(e2NodeComponentInfo->componentResponsePart, e2NodeComponentInfo->rspBufSize);
1618 DU_FREE(e2NodeComponentInfo, sizeof(E2NodeComponent));
1619 DU_FREE(node, sizeof(CmLList));
1622 BuildAndSendE2NodeConfigUpdate();
1626 /******************************************************************
1628 * @brief Processes RIC Subscription Req sent by RIC
1632 * Function : procRicSubsReq
1634 * Functionality: Processes E2 Setup Response sent by CU
1636 * @params[in] E2AP_PDU_t ASN decoded E2AP message
1637 * @return ROK - success
1640 * ****************************************************************/
1642 uint8_t procRicSubsReq(E2AP_PDU_t *e2apMsg)
1647 CmLList *ricSubscriptionNode = NULLP;
1648 RICsubscriptionRequest_t *ricSubsReq;
1649 RicSubscription *ricSubscriptionInfo;
1650 RICaction_ToBeSetup_ItemIEs_t *actionItem;
1652 DU_LOG("\nINFO --> E2AP : RIC Subscription request received");
1653 ricSubsReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
1655 for(idx=0; idx<ricSubsReq->protocolIEs.list.count; idx++)
1657 if(ricSubsReq->protocolIEs.list.array[idx])
1659 switch(ricSubsReq->protocolIEs.list.array[idx]->id)
1661 case ProtocolIE_IDE2_id_RICrequestID:
1663 /* TODO :- ricSubscriptionInfo details will be stored based on
1664 * RAN function id, so first we need to search RAN function and then add
1665 * subscription details to that ran function */
1666 DU_ALLOC(ricSubscriptionInfo, sizeof(RicSubscription));
1667 if(!ricSubscriptionInfo)
1669 DU_LOG("\nERROR --> E2AP : Memory allocation failed for ricSubscriptionInfo");
1672 ricSubscriptionInfo->requestId.requestorId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID;
1673 ricSubscriptionInfo->requestId.instanceId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID;
1674 DU_ALLOC(ricSubscriptionNode, sizeof(CmLList));
1675 if(ricSubscriptionNode)
1677 ricSubscriptionNode->node = (PTR) ricSubscriptionInfo;
1678 cmLListAdd2Tail(&duCb.e2apDb.ranFunction[0].subscriptionList,ricSubscriptionNode);
1682 case ProtocolIE_IDE2_id_RANfunctionID:
1684 duCb.e2apDb.ranFunction[0].id = ricSubsReq->protocolIEs.list.array[idx]-> \
1685 value.choice.RANfunctionID;
1688 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
1690 if(ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.\
1693 actionItem =(RICaction_ToBeSetup_ItemIEs_t *)ricSubsReq->protocolIEs.list\
1694 .array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List\
1697 for(ied = 0; ied < ricSubsReq->protocolIEs.list.array[idx]->value.choice.\
1698 RICsubscriptionDetails.ricAction_ToBeSetup_List.list.count; ied++)
1700 switch(actionItem->id)
1702 case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
1704 ricSubscriptionInfo->actionSequence[0].id = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID;
1705 ricSubscriptionInfo->actionSequence[0].type = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType;
1709 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
1714 free(ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.\
1717 #ifdef KPI_CALCULATION
1718 /* This is a dummy trigger for statistics request. It will
1719 * be removed in next gerrit and actual statistics request
1720 * will be sent when RIC subscription request is received
1722 ricSubscriptionInfo->actionSequence[0].definition.styleType = 1;
1723 BuildAndSendStatsReq(ricSubscriptionInfo->actionSequence[0].definition);
1730 DU_LOG("\nERROR --> E2AP : Invalid IE received in RIC SubsReq:%ld",
1731 ricSubsReq->protocolIEs.list.array[idx]->id);
1734 free(ricSubsReq->protocolIEs.list.array[idx]);
1737 free(ricSubsReq->protocolIEs.list.array);
1738 ret = BuildAndSendRicSubscriptionRsp();
1740 BuildAndSendRicIndication(ricSubscriptionInfo);
1746 /*******************************************************************
1748 * @brief Free the RicIndication Message
1752 * Function : FreeRicIndication
1754 * Functionality: Free the RicIndication Message
1759 ******************************************************************/
1760 void FreeRicIndication(E2AP_PDU_t *e2apMsg)
1763 RICindication_t *ricIndicationMsg= NULLP;
1766 if(e2apMsg != NULLP)
1768 if(e2apMsg->choice.initiatingMessage != NULLP)
1770 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
1771 if(ricIndicationMsg!= NULLP)
1773 if(ricIndicationMsg->protocolIEs.list.array != NULLP)
1775 for(idx=0; idx<ricIndicationMsg->protocolIEs.list.count; idx++)
1777 if(ricIndicationMsg->protocolIEs.list.array[idx] != NULLP)
1779 switch(ricIndicationMsg->protocolIEs.list.array[idx]->id)
1781 case ProtocolIE_IDE2_id_RICrequestID:
1784 case ProtocolIE_IDE2_id_RANfunctionID:
1787 case ProtocolIE_IDE2_id_RICactionID:
1790 case ProtocolIE_IDE2_id_RICindicationType:
1793 case ProtocolIE_IDE2_id_RICindicationHeader:
1795 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf,\
1796 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
1799 case ProtocolIE_IDE2_id_RICindicationMessage:
1801 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf,\
1802 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
1808 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx],sizeof(RICindication_IEs_t));
1811 DU_FREE(ricIndicationMsg->protocolIEs.list.array,ricIndicationMsg->protocolIEs.list.size);
1814 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1816 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1819 /*******************************************************************
1821 * brief Fill the RicIndication Message
1825 * Function : FillRicIndication
1827 * Functionality:Fills the RicIndication Message
1829 * @return ROK - success
1832 ******************************************************************/
1833 uint8_t FillRicIndication(RICindication_t *ricIndicationMsg, RicSubscription *ricSubscriptionInfo)
1835 uint8_t elementCnt=0;
1840 ricIndicationMsg->protocolIEs.list.count = elementCnt;
1841 ricIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(RICindication_t);
1842 /* Initialize the Ric Indication members */
1843 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array, \
1844 ricIndicationMsg->protocolIEs.list.size);
1845 if(ricIndicationMsg->protocolIEs.list.array == NULLP)
1847 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
1852 for(idx=0; idx<elementCnt; idx++)
1854 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx],\
1855 sizeof(RICindication_IEs_t));
1856 if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP)
1858 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
1866 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
1867 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1868 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1869 RICindication_IEs__value_PR_RICrequestID;
1870 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID =ricSubscriptionInfo->requestId.requestorId;
1871 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID = ricSubscriptionInfo->requestId.instanceId;
1874 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
1875 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1876 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1877 RICindication_IEs__value_PR_RANfunctionID;
1878 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RANfunctionID = duCb.e2apDb.ranFunction[0].id;
1881 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionID;
1882 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1883 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1884 RICindication_IEs__value_PR_RICactionID;
1885 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICactionID = ricSubscriptionInfo->actionSequence[0].id;
1888 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationType;
1889 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1890 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1891 RICindication_IEs__value_PR_RICindicationType;
1892 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationType = ricSubscriptionInfo->actionSequence[0].type;
1895 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationHeader;
1896 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1897 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1898 RICindication_IEs__value_PR_RICindicationHeader;
1899 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size = 3 *
1901 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf ,\
1902 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
1903 if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf == NULLP)
1905 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
1910 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
1911 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf);
1913 /* TO BE CHANGED: RIC INDICATION DATA */
1914 /* For now filling a dummy octect data, need to tested with PRBs*/
1915 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationMessage;
1916 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1917 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1918 RICindication_IEs__value_PR_RICindicationMessage;
1919 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size = 3 *
1921 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf ,\
1922 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
1923 if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf == NULLP)
1925 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
1930 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
1931 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf);
1939 /*******************************************************************
1941 * @brief Builds and Send the RicIndication Message
1945 * Function : BuildAndSendRicIndication
1947 * Functionality:Fills the RicIndication Message
1949 * @return ROK - success
1952 ******************************************************************/
1954 uint8_t BuildAndSendRicIndication(RicSubscription *ricSubscriptionInfo)
1956 E2AP_PDU_t *e2apMsg = NULLP;
1957 RICindication_t *ricIndicationMsg=NULLP;
1958 asn_enc_rval_t encRetVal; /* Encoder return value */
1959 uint8_t ret = RFAILED;
1960 uint8_t FillRicIndicationret = ROK;
1964 DU_LOG("\nINFO --> E2AP : Building RIC Indication Message\n");
1966 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1967 if(e2apMsg == NULLP)
1969 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1973 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
1974 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1975 if(e2apMsg->choice.initiatingMessage == NULLP)
1977 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1980 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication;
1981 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
1982 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICindication;
1984 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
1986 FillRicIndicationret = FillRicIndication(ricIndicationMsg, ricSubscriptionInfo);
1987 if(FillRicIndicationret != ROK)
1991 /* Prints the Msg formed */
1992 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1993 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1995 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1997 if(encRetVal.encoded == ENCODE_FAIL)
1999 DU_LOG("\nERROR --> E2AP : Could not encode RIC Indication Message (at %s)\n",\
2000 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2005 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Indication Message \n");
2006 #ifdef DEBUG_ASN_PRINT
2007 for(int i=0; i< encBufSize; i++)
2009 printf("%x",encBuf[i]);
2014 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
2016 DU_LOG("\nINFO --> E2AP : Sending RIC Indication Message");
2022 FreeRicIndication(e2apMsg);
2026 /*******************************************************************
2028 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
2032 * Function : FreeE2NodeConfigUpdate
2035 * - freeing the memory allocated for E2nodeConfigurationUpdate
2037 * @params[in] E2AP_PDU_t *e2apMsg
2038 * @return ROK - success
2041 * ****************************************************************/
2042 void FreeE2NodeConfigUpdate(E2AP_PDU_t *e2apMsg)
2045 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate;
2047 if(e2apMsg != NULLP)
2049 if(e2apMsg->choice.initiatingMessage != NULLP)
2051 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
2052 if(e2NodeConfigUpdate->protocolIEs.list.array != NULLP)
2054 for(arrIdx = 0; arrIdx < e2NodeConfigUpdate->protocolIEs.list.count; arrIdx++)
2056 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
2058 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
2060 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2062 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2066 /*******************************************************************
2068 * @brief Buld and send the E2 node config update msg
2072 * Function : BuildAndSendE2NodeConfigUpdate
2075 * - Buld and send the E2 node config update msg
2078 * @return ROK - success
2081 * ****************************************************************/
2083 uint8_t BuildAndSendE2NodeConfigUpdate()
2085 uint8_t arrIdx = 0,elementCnt = 1;
2087 E2AP_PDU_t *e2apMsg = NULLP;
2088 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate = NULLP;
2089 asn_enc_rval_t encRetVal; /* Encoder return value */
2091 DU_LOG("\nINFO --> E2AP : Building E2 Node config update\n");
2094 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2095 if(e2apMsg == NULLP)
2097 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2100 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
2101 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2102 if(e2apMsg->choice.initiatingMessage == NULLP)
2104 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2105 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2108 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
2109 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
2110 e2apMsg->choice.initiatingMessage->value.present = \
2111 InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate;
2112 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
2114 e2NodeConfigUpdate->protocolIEs.list.count = elementCnt;
2115 e2NodeConfigUpdate->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdate_IEs_t*);
2116 /* Initialize the Ric Indication members */
2117 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array, \
2118 e2NodeConfigUpdate->protocolIEs.list.size);
2119 if(e2NodeConfigUpdate->protocolIEs.list.array == NULLP)
2121 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
2125 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
2127 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
2128 if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx] == NULLP)
2131 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
2138 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2139 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2140 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_TransactionID;
2141 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = TRANS_ID;
2144 /* Prints the Msg formed */
2145 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2147 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2149 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
2151 if(encRetVal.encoded == ENCODE_FAIL)
2153 DU_LOG("\nERROR --> E2AP : Could not encode E2nodeConfigurationUpdate structure (at %s)\n",\
2154 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2159 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2nodeConfigurationUpdate\n");
2160 #ifdef DEBUG_ASN_PRINT
2161 for(int i=0; i< encBufSize; i++)
2163 printf("%x",encBuf[i]);
2167 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize))
2169 DU_LOG("\nERROR --> E2AP : Sending E2 node config update failed");
2176 FreeE2NodeConfigUpdate(e2apMsg);
2180 /*******************************************************************
2182 * @brief Deallocate the memory allocated for E2ResetRequest msg
2186 * Function : FreeE2ResetRequest
2189 * - freeing the memory allocated for E2ResetRequest
2191 * @params[in] E2AP_PDU_t *e2apMsg
2192 * @return ROK - success
2195 * ****************************************************************/
2196 void FreeE2ResetRequest(E2AP_PDU_t *e2apMsg)
2199 ResetRequestE2_t *resetReq = NULLP;
2201 if(e2apMsg != NULLP)
2203 if(e2apMsg->choice.initiatingMessage != NULLP)
2205 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
2206 if(resetReq->protocolIEs.list.array)
2208 for(ieIdx = 0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
2210 DU_FREE(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
2212 DU_FREE(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
2214 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2216 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
2220 /*******************************************************************
2222 * @brief Build and send the E2 reset request msg
2226 * Function : BuildAndSendE2ResetRequest
2229 * - Buld and send the E2 reset request msg to RIC
2232 * @return ROK - success
2235 * ****************************************************************/
2236 uint8_t BuildAndSendE2ResetRequest(E2CauseType failureType, E2Cause failureCause)
2238 uint8_t ieIdx = 0, elementCnt = 0, transId = 0;
2239 uint8_t ret = RFAILED;
2240 E2AP_PDU_t *e2apMsg = NULLP;
2241 ResetRequestE2_t *resetReq = NULLP;
2242 asn_enc_rval_t encRetVal; /* Encoder return value */
2244 DU_LOG("\nINFO --> E2AP : Building E2 Reset Request\n");
2248 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2249 if(e2apMsg == NULLP)
2251 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for E2AP-PDU failed");
2255 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
2256 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
2257 if(e2apMsg->choice.initiatingMessage == NULLP)
2259 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for initiatingMessage");
2263 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset;
2264 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
2265 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2;
2266 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
2269 resetReq->protocolIEs.list.count = elementCnt;
2270 resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *);
2272 DU_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
2273 if(!resetReq->protocolIEs.list.array)
2275 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
2276 Reset Request IE array");
2280 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
2282 DU_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
2283 if(!resetReq->protocolIEs.list.array[ieIdx])
2285 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
2286 Reset Request IE array element");
2291 /* In case of failure */
2292 if(ieIdx < elementCnt)
2296 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2297 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
2298 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID;
2299 transId = assignTransactionId();
2300 resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
2303 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
2304 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
2305 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2;
2306 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present = failureType;
2307 switch(resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present)
2309 case CauseE2_PR_NOTHING:
2311 case CauseE2_PR_ricRequest:
2312 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricRequest = failureCause;
2314 case CauseE2_PR_ricService:
2315 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricService = failureCause;
2317 case CauseE2_PR_e2Node:
2318 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.e2Node = failureCause;
2320 case CauseE2_PR_transport:
2321 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.transport = failureCause;
2323 case CauseE2_PR_protocol:
2324 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.protocol = failureCause;
2326 case CauseE2_PR_misc:
2327 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.misc = failureCause;
2331 /* Prints the Msg formed */
2332 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2334 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2336 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
2338 if(encRetVal.encoded == ENCODE_FAIL)
2340 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\
2341 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2346 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n");
2347 #ifdef DEBUG_ASN_PRINT
2348 for(int i=0; i< encBufSize; i++)
2350 printf("%x",encBuf[i]);
2354 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
2356 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
2360 /* In case the message is sent successfully, store the transaction info to
2361 * be used when response is received */
2362 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
2363 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
2369 /* Free all memory */
2370 FreeE2ResetRequest(e2apMsg);
2374 /*******************************************************************
2376 * @brief Deallocate the memory allocated for Reset Response msg
2380 * Function : freeAperDecodingOfE2ResetRsp
2383 * - freeing the memory allocated for Reset response
2385 * @params[in] ResetResponseE2_t *resetResponse
2388 * ****************************************************************/
2389 void freeAperDecodingOfE2ResetRsp(ResetResponseE2_t *resetResponse)
2395 if(resetResponse->protocolIEs.list.array)
2397 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
2399 if(resetResponse->protocolIEs.list.array[ieIdx])
2401 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
2403 case ProtocolIE_IDE2_id_TransactionID:
2406 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
2409 free(resetResponse->protocolIEs.list.array[ieIdx]);
2412 free(resetResponse->protocolIEs.list.array);
2417 /******************************************************************
2419 * @brief Processes E2 Reset Response sent by RIC
2423 * Function : procResetResponse
2425 * Functionality: Processes E2 Reset Response sent by RIC
2427 * @params[in] E2AP_PDU_t ASN decoded E2AP message
2428 * @return ROK - success
2431 * ****************************************************************/
2432 uint8_t procResetResponse(E2AP_PDU_t *e2apMsg)
2434 uint8_t ieIdx =0, transId;
2435 ResetResponseE2_t *resetResponse;
2437 DU_LOG("\nINFO --> E2AP : E2 Reset Response received");
2438 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;;
2440 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
2442 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
2444 case ProtocolIE_IDE2_id_TransactionID:
2445 transId = resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
2446 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) && \
2447 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
2449 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
2453 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
2457 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
2458 /* As per ORAN WG3 E2AP spec v3.0, section 9.2.2
2459 Criticality Diagnostics IE is sent by Near-RT RIC when parts of a received message i.e.
2460 Reset Request in this case, have not been comprehended or were missing, or if the message
2461 contained logical errors.
2463 Processing of this ID should be implemented when negative call flows are to be supported.
2467 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2 Reset Response : %ld",
2468 resetResponse->protocolIEs.list.array[ieIdx]->id);
2473 freeAperDecodingOfE2ResetRsp(resetResponse);
2477 /******************************************************************
2479 * @brief Deallocation of memory allocated bu aper decoder for e2 setup Failure
2483 * Function : freeAperDecodingOfE2SetupFailure
2485 * Functionality: Deallocation of memory allocated bu aper decoder for e2
2488 * @params[in] E2setupFailure_t *e2SetupFailure;
2491 * ****************************************************************/
2492 void freeAperDecodingOfE2SetupFailure(E2setupFailure_t *e2SetupFailure)
2498 if(e2SetupFailure->protocolIEs.list.array)
2500 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
2502 if(e2SetupFailure->protocolIEs.list.array[arrIdx])
2504 free(e2SetupFailure->protocolIEs.list.array[arrIdx]);
2507 free(e2SetupFailure->protocolIEs.list.array);
2511 /******************************************************************
2513 * @brief Processes E2 Setup Failure sent by RIC
2517 * Function : procE2SetupFailure
2519 * Functionality: Processes E2 Setup failure sent by RIC
2521 * @params[in] E2AP_PDU_t ASN decoded E2AP message
2522 * @return ROK - success
2525 * ****************************************************************/
2526 void procE2SetupFailure(E2AP_PDU_t *e2apMsg)
2528 uint8_t arrIdx =0, transId =0, timerValue=0;
2529 E2setupFailure_t *e2SetupFailure;
2531 DU_LOG("\nINFO --> E2AP : E2 Setup failure received");
2532 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
2534 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
2536 switch(e2SetupFailure->protocolIEs.list.array[arrIdx]->id)
2538 case ProtocolIE_IDE2_id_TransactionID:
2540 transId = e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
2541 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
2542 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
2544 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
2548 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
2553 case ProtocolIE_IDE2_id_TimeToWaitE2:
2555 timerValue = covertE2WaitTimerEnumToValue(e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
2556 if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR)) == FALSE)
2558 duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR, timerValue);
2562 DU_LOG("\nERROR --> E2AP : EVENT_E2_SETUP_TMR timer is already running");
2570 freeAperDecodingOfE2SetupFailure(e2SetupFailure);
2572 /*******************************************************************
2574 * @brief Handles received E2AP message and sends back response
2578 * Function : E2APMsgHdlr
2581 * - Decodes received E2AP control message
2582 * - Prepares response message, encodes and sends to SCTP
2585 * @return ROK - success
2588 * ****************************************************************/
2589 void E2APMsgHdlr(Buffer *mBuf)
2592 char *recvBuf = NULLP;
2594 MsgLen recvBufLen =0;
2595 E2AP_PDU_t *e2apMsg = NULLP;
2596 asn_dec_rval_t rval ={0}; /* Decoder return value */
2597 E2AP_PDU_t e2apasnmsg={0} ;
2599 DU_LOG("\nDEBUG --> E2AP : Received E2AP message buffer");
2600 ODU_PRINT_MSG(mBuf, 0,0);
2602 /* Copy mBuf into char array to decode it */
2603 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
2604 DU_ALLOC(recvBuf, (Size)recvBufLen);
2606 if(recvBuf == NULLP)
2608 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
2611 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
2613 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
2617 #ifdef DEBUG_ASN_PRINT
2618 printf("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
2619 for(i=0; i< recvBufLen; i++)
2621 printf("%x",recvBuf[i]);
2625 /* Decoding flat buffer into E2AP messsage */
2626 e2apMsg = &e2apasnmsg;
2627 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
2629 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
2630 DU_FREE(recvBuf, (Size)recvBufLen);
2632 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2634 DU_LOG("\nERROR --> E2AP : ASN decode failed");
2638 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2640 switch(e2apMsg->present)
2642 case E2AP_PDU_PR_unsuccessfulOutcome:
2644 switch(e2apMsg->choice.unsuccessfulOutcome->value.present)
2646 case UnsuccessfulOutcomeE2__value_PR_E2setupFailure:
2648 procE2SetupFailure(e2apMsg);
2653 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_unsuccessfulOutcome [%d]",\
2654 e2apMsg->choice.unsuccessfulOutcome->value.present);
2660 case E2AP_PDU_PR_successfulOutcome:
2662 switch(e2apMsg->choice.successfulOutcome->value.present)
2664 case SuccessfulOutcomeE2__value_PR_E2setupResponse:
2668 procE2SetupRsp(e2apMsg);
2672 case SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge:
2674 DU_LOG("\nDEBUG --> E2AP : E2 node Config update ack message recevied");
2677 case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
2679 procResetResponse(e2apMsg);
2684 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_successfulOutcome [%d]",\
2685 e2apMsg->choice.successfulOutcome->value.present);
2688 }/* End of switch(successfulOutcome) */
2689 free(e2apMsg->choice.successfulOutcome);
2693 case E2AP_PDU_PR_initiatingMessage:
2695 switch(e2apMsg->choice.initiatingMessage->value.present)
2697 case InitiatingMessageE2__value_PR_RICsubscriptionRequest:
2699 procRicSubsReq(e2apMsg);
2704 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\
2705 e2apMsg->choice.initiatingMessage->value.present);
2708 }/* End of switch(initiatingMessage) */
2709 free(e2apMsg->choice.initiatingMessage);
2714 DU_LOG("\nERROR --> E2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
2719 }/* End of switch(e2apMsg->present) */
2721 } /* End of E2APMsgHdlr */
2723 /**********************************************************************
2725 **********************************************************************/