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"
54 #include "MeasurementRecord.h"
55 #include "MeasurementData.h"
56 #include "MeasurementRecordItem.h"
57 #include "MeasurementDataItem.h"
58 #include "E2SM-KPM-IndicationMessage-Format1.h"
59 #include "E2SM-KPM-IndicationMessage.h"
60 #include "E2SM-KPM-IndicationHeader.h"
61 #include "E2SM-KPM-IndicationHeader-Format1.h"
62 #include "LabelInfoItem.h"
64 /*******************************************************************
66 * @brief Fill E2 Failure Cause
70 * Function : fillE2Cause
72 * Functionality: Fill E2 Failure Cause
74 * @params[in] E2 Cause pointer to be filled in
75 * E2 Cause to be filled from
78 ******************************************************************/
79 void fillE2Cause(CauseE2_t *e2Cause, E2FailureCause failureCause)
81 e2Cause->present = failureCause.causeType;
82 switch(e2Cause->present)
84 case CauseE2_PR_ricRequest:
86 e2Cause->choice.ricRequest = failureCause.cause;
89 case CauseE2_PR_ricService:
91 e2Cause->choice.ricService = failureCause.cause;
94 case CauseE2_PR_e2Node:
96 e2Cause->choice.e2Node = failureCause.cause;
99 case CauseE2_PR_transport:
101 e2Cause->choice.transport = failureCause.cause;
104 case CauseE2_PR_protocol:
106 e2Cause->choice.protocol = failureCause.cause;
109 case CauseE2_PR_misc:
111 e2Cause->choice.misc = failureCause.cause;
114 case CauseE2_PR_NOTHING:
120 /*******************************************************************
122 * @brief Printing Type and Cause of failure
126 * Function : printE2ErrorCause
128 * Functionality: Printing Type and Cause of failure
130 * @params[in] E2 Cause
133 ******************************************************************/
134 void printE2ErrorCause(CauseE2_t *cause)
136 switch(cause->present)
138 case CauseE2_PR_ricRequest:
140 DU_LOG("Failure_Type [%s] Cause [%ld]", "RIC_Request", cause->choice.ricRequest);
143 case CauseE2_PR_ricService:
145 DU_LOG("Failure_Type [%s] Cause [%ld]", "RIC_Service", cause->choice.ricService);
148 case CauseE2_PR_e2Node:
150 DU_LOG("Failure_Type [%s] Cause [%ld]", "E2_Node", cause->choice.e2Node);
153 case CauseE2_PR_transport:
155 DU_LOG("Failure_Type [%s] Cause [%ld]", "Transport", cause->choice.transport);
158 case CauseE2_PR_protocol:
160 DU_LOG("Failure_Type [%s] Cause [%ld]", "Protocol", cause->choice.protocol);
163 case CauseE2_PR_misc:
165 DU_LOG("Failure_Type [%s] Cause [%ld]", "Miscellaneous", cause->choice.misc);
170 DU_LOG("Failure_Type and Cause unknown");
176 /*******************************************************************
178 * @brief Free the ErrorIndication Message
182 * Function : FreeRicIndication
184 * Functionality: Free the ErrorIndication Message
187 * E2AP_PDU is to freed
190 ******************************************************************/
191 void FreeErrorIndication(E2AP_PDU_t *e2apMsg)
194 ErrorIndicationE2_t *errorIndicationMsg= NULLP;
198 if(e2apMsg->choice.initiatingMessage != NULLP)
200 errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
201 if(errorIndicationMsg!= NULLP)
203 if(errorIndicationMsg->protocolIEs.list.array != NULLP)
205 for(arrIdx=0; arrIdx<errorIndicationMsg->protocolIEs.list.count; arrIdx++)
207 DU_FREE(errorIndicationMsg->protocolIEs.list.array[arrIdx],sizeof(ErrorIndicationE2_t));
209 DU_FREE(errorIndicationMsg->protocolIEs.list.array,errorIndicationMsg->protocolIEs.list.size);
212 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
214 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
218 /*******************************************************************
220 * @brief Builds and Send the ErrorIndication Message
224 * Function : BuildAndSendErrorIndication
226 * Functionality:Fills the ErrorIndication Message
233 * @return ROK - success
236 ******************************************************************/
238 uint8_t BuildAndSendErrorIndication(int8_t transId, RicRequestId requestId, uint16_t ranFuncId, E2FailureCause failureCause)
240 uint8_t elementCnt =0, arrIdx=0, ret = RFAILED;
241 E2AP_PDU_t *e2apMsg = NULLP;
242 ErrorIndicationE2_t *errorIndicationMsg=NULLP;
243 asn_enc_rval_t encRetVal; /* Encoder return value */
247 DU_LOG("\nINFO --> E2AP : Building Error Indication Message\n");
249 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
252 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
256 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
257 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
258 if(e2apMsg->choice.initiatingMessage == NULLP)
260 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed in %s at line %d",__func__, __LINE__);
263 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_ErrorIndicationE2;
264 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
265 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ErrorIndicationE2;
267 errorIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.ErrorIndicationE2;
269 /* Element count is 2 for TransactionID/RICrequestID and Cause.
270 * If the RAN function id is present, the count will be increased.*/
277 errorIndicationMsg->protocolIEs.list.count = elementCnt;
278 errorIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(ErrorIndicationE2_IEs_t*);
280 /* Initialize the E2Setup members */
281 DU_ALLOC(errorIndicationMsg->protocolIEs.list.array, errorIndicationMsg->protocolIEs.list.size);
282 if(errorIndicationMsg->protocolIEs.list.array == NULLP)
284 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements in %s at line %d",__func__, __LINE__);
288 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
290 DU_ALLOC(errorIndicationMsg->protocolIEs.list.array[arrIdx], sizeof(ErrorIndicationE2_IEs_t));
291 if(errorIndicationMsg->protocolIEs.list.array[arrIdx] == NULLP)
293 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array [%d] elements in %s at line %d", arrIdx, __func__, __LINE__);
297 if(arrIdx < elementCnt)
302 if(transId >=0 && transId<=255)
305 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
306 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
307 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_TransactionID;
308 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
313 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RICrequestID;
314 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
315 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RICrequestID;
316 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricRequestorID = requestId.requestorId;
317 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RICrequestID.ricInstanceID = requestId.instanceId;
322 /* RAN Function ID */
324 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionID;
325 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
326 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_RANfunctionID;
327 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionID = ranFuncId;
332 errorIndicationMsg->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
333 errorIndicationMsg->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
334 errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.present = ErrorIndicationE2_IEs__value_PR_CauseE2;
335 fillE2Cause(&errorIndicationMsg->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, failureCause);
337 /* Prints the Msg formed */
338 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
339 memset(encBuf, 0, ENC_BUF_MAX_LEN);
341 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
343 if(encRetVal.encoded == ENCODE_FAIL)
345 DU_LOG("\nERROR --> E2AP : Could not encode Error Indication Message (at %s)\n",\
346 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
351 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for Error Indication Message \n");
352 #ifdef DEBUG_ASN_PRINT
353 for(int i=0; i< encBufSize; i++)
355 printf("%x",encBuf[i]);
360 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
362 DU_LOG("\nINFO --> E2AP : Sending Error Indication Message");
368 FreeErrorIndication(e2apMsg);
372 /******************************************************************
374 * @brief Deallocation of memory allocated by aper decoder for e2
375 * Config Update Failure
379 * Function : freeAperDecodingOfE2Node Config UpdateFailure
381 * Functionality: Deallocation of memory allocated by aper decoder
382 * for e2 Config Update Failure
384 * @params[in] E2nodeConfigurationUpdateFailure_t to be deallocated
387 * ****************************************************************/
389 void freeAperDecodingOfE2NodeConfigUpdateFailure(E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail)
395 if(e2NodeCfgUpdFail->protocolIEs.list.array)
397 for(arrIdx=0; arrIdx<e2NodeCfgUpdFail->protocolIEs.list.count; arrIdx++)
399 if(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx])
401 free(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]);
404 free(e2NodeCfgUpdFail->protocolIEs.list.array);
409 /******************************************************************
411 * @brief Processes E2 Node Config Update Failure sent by RIC
415 * Function : procE2NodeConfigUpdateFailure
417 * Functionality: Processes E2 Node Config Update failure sent by RIC
419 * @params[in] E2AP_PDU_t ASN decoded E2AP message
420 * @return ROK - success
423 * ****************************************************************/
425 void procE2NodeConfigUpdateFailure(E2AP_PDU_t *e2apMsg)
427 uint8_t arrIdx =0, transId =0, timerValue=0;
428 E2nodeConfigurationUpdateFailure_t *e2NodeCfgUpdFail=NULL;
430 DU_LOG("\nINFO --> E2AP : E2 Node Config Update failure received");
431 e2NodeCfgUpdFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2nodeConfigurationUpdateFailure;
433 for(arrIdx=0; arrIdx<e2NodeCfgUpdFail->protocolIEs.list.count; arrIdx++)
435 switch(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]->id)
437 case ProtocolIE_IDE2_id_TransactionID:
439 transId = e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
440 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
441 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
443 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
447 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
451 case ProtocolIE_IDE2_id_TimeToWaitE2:
453 timerValue = convertE2WaitTimerEnumToValue(e2NodeCfgUpdFail->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
454 if((duChkTmr((PTR)&(duCb.e2apDb), EVENT_E2_NODE_CONFIG_UPDATE_TMR)) == FALSE)
456 duStartTmr((PTR)&(duCb.e2apDb), EVENT_E2_NODE_CONFIG_UPDATE_TMR, timerValue);
460 DU_LOG("\nERROR --> E2AP : EVENT_E2_NODE_CONFIG_UPDATE_TMR timer is already running");
467 freeAperDecodingOfE2NodeConfigUpdateFailure(e2NodeCfgUpdFail);
470 /*******************************************************************
472 * @brief Builds Global gNodeB Params
476 * Function : BuildGlobalgNBId
478 * Functionality: Building the Plmn and gNB id
480 * @params[in] GlobalE2node_gNB_ID_t *gNbId
481 * @return ROK - success
484 ******************************************************************/
486 uint8_t BuildGlobalgNBId(GlobalE2node_gNB_ID_t *gNbId)
489 uint8_t byteSize = 4;
490 uint8_t gnbId = duCb.gnbId;
493 /* fill Global gNB ID Id */
494 gNbId->global_gNB_ID.plmn_id.size = 3 * sizeof(uint8_t);
495 gNbId->global_gNB_ID.plmn_id.buf = NULLP;
496 DU_ALLOC(gNbId->global_gNB_ID.plmn_id.buf , gNbId->global_gNB_ID.plmn_id.size);
497 if(gNbId->global_gNB_ID.plmn_id.buf == NULLP)
499 DU_LOG("\nERROR --> E2AP: Memory allocation failed for Plmn buffer");
504 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
505 gNbId->global_gNB_ID.plmn_id.buf);
506 gNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID;
507 /* Allocate Buffer size */
508 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size = byteSize * sizeof(uint8_t);
509 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf = NULLP;
510 DU_ALLOC(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf, \
511 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
512 if(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf == NULLP)
514 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gnb buffer");
519 fillBitString(&gNbId->global_gNB_ID.gnb_id.choice.gnb_ID, unused, byteSize, gnbId);
524 DU_ALLOC( gNbId->gNB_DU_ID, sizeof(GNB_DU_ID_t));
525 if(gNbId->gNB_DU_ID == NULLP)
527 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gNB_DU_ID ");
532 gNbId->gNB_DU_ID->size = sizeof(uint8_t);
533 DU_ALLOC( gNbId->gNB_DU_ID->buf, sizeof(uint8_t));
534 if(gNbId->gNB_DU_ID->buf)
536 gNbId->gNB_DU_ID->buf[0] =duCb.e2apDb.e2NodeId;
540 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gNB_DU_ID buffer");
548 /*******************************************************************
550 * @brief fill the E2 node config information
554 * Function : fillE2NodeConfig
556 * Functionality: fill E2 node config information
559 * Pointer to e2NodeCfg to be filled
560 * E2 Node Component information
561 * Type of configuration
562 * @return ROK - success
565 ******************************************************************/
567 uint8_t fillE2NodeConfig(PTR e2NodeCfg, E2NodeComponent *e2NodeComponentInfo, ConfigType configType)
569 E2nodeComponentInterfaceType_t *interfaceType=NULLP;
570 E2nodeComponentID_t *componentID =NULLP;
571 E2nodeComponentConfiguration_t *configuration=NULLP;
572 E2nodeComponentConfigAddition_Item_t *e2NodeAddItem=NULL;
573 E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULL;
574 E2nodeComponentConfigRemoval_Item_t *e2NodeRemovalItem=NULL;
580 e2NodeAddItem = (E2nodeComponentConfigAddition_Item_t*)e2NodeCfg;
581 interfaceType = &e2NodeAddItem->e2nodeComponentInterfaceType;
582 componentID = &e2NodeAddItem->e2nodeComponentID;
583 configuration = &e2NodeAddItem->e2nodeComponentConfiguration;
588 e2NodeUpdateItem = (E2nodeComponentConfigUpdate_Item_t *) e2NodeCfg;
589 interfaceType = &e2NodeUpdateItem->e2nodeComponentInterfaceType;
590 componentID = &e2NodeUpdateItem->e2nodeComponentID;
591 configuration = &e2NodeUpdateItem->e2nodeComponentConfiguration;
596 e2NodeRemovalItem = (E2nodeComponentConfigRemoval_Item_t*) e2NodeCfg;
597 interfaceType = &e2NodeRemovalItem->e2nodeComponentInterfaceType;
598 componentID = &e2NodeRemovalItem->e2nodeComponentID;
603 DU_LOG("\nERROR --> E2AP : Configuration type %d does not supported ", configType);
607 /* E2nodeComponentInterfaceType */
608 *interfaceType = convertInterfaceToE2ComponentInterfaceType(e2NodeComponentInfo->interfaceType);
610 /* We now only support the F1 interface out of these interfaces
611 * (NG,XN,E1,F1,W1,S1,X2), therefore only the F1 component identifier was filled in. */
613 if(*interfaceType == F1)
615 /* E2 Node Component ID */
616 componentID->present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
617 DU_ALLOC(componentID->choice.e2nodeComponentInterfaceTypeF1,sizeof(E2nodeComponentInterfaceF1_t));
618 if(componentID->choice.e2nodeComponentInterfaceTypeF1 == NULLP)
620 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
623 componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
624 DU_ALLOC(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
625 componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
627 if(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
629 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
632 memcpy(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf, &e2NodeComponentInfo->componentId,\
633 componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
636 if(configType == CONFIG_DEL)
638 /* We don't need to fill out the E2 Node Component Request and Response
639 * information in the case of CONFIG_DEL, therefore returning ROK from here. */
643 /* E2 Node Component Request Part */
644 if(e2NodeComponentInfo->componentRequestPart)
646 configuration->e2nodeComponentRequestPart.size = e2NodeComponentInfo->reqBufSize ;
647 DU_ALLOC(configuration->e2nodeComponentRequestPart.buf,\
648 configuration->e2nodeComponentRequestPart.size);
649 if(configuration->e2nodeComponentRequestPart.buf == NULLP)
651 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
655 memcpy(configuration->e2nodeComponentRequestPart.buf,\
656 e2NodeComponentInfo->componentRequestPart, configuration->\
657 e2nodeComponentRequestPart.size);
661 DU_LOG("\nERROR --> E2AP: componentRequestPart is null ");
665 /* E2 Node Component Response Part */
666 if(e2NodeComponentInfo->componentResponsePart)
668 configuration->e2nodeComponentResponsePart.size = e2NodeComponentInfo->rspBufSize;
669 DU_ALLOC(configuration->e2nodeComponentResponsePart.buf, configuration->e2nodeComponentResponsePart.size);
670 if(configuration->e2nodeComponentResponsePart.buf == NULLP)
672 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at line %d",__func__,__LINE__);
675 memcpy(configuration->e2nodeComponentResponsePart.buf, e2NodeComponentInfo->componentResponsePart, configuration->\
676 e2nodeComponentResponsePart.size);
680 DU_LOG("\nERROR --> E2AP: componentResponsePart is null");
687 /*******************************************************************
689 * @brief Builds E2 node config addition list
693 * Function : BuildE2NodeConfigAddList
695 * Functionality: Building E2 node config addition list
698 * E2nodeComponentConfigAddition_List_t to be filled
700 * Count of E2 node to be added in the list
701 * Received list of E2 node configuration
703 * @return ROK - success
706 ******************************************************************/
708 uint8_t BuildE2NodeConfigAddList(E2nodeComponentConfigAddition_List_t *e2NodeAddList, uint8_t procedureCode, uint16_t count, E2NodeConfigItem *e2NodeList)
712 E2NodeComponent *e2NodeComponentInfo=NULL;
713 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItemIe=NULL;
714 E2nodeComponentConfigAddition_Item_t *e2NodeAddItem=NULL;
717 /* For ProcedureCodeE2_id_E2setup, the number of E2 node configuration list items is
718 * equal to the number of E2 node configuration entries stored in the database.
719 * For any other procedure, the E2 node configuration list count is equal
720 * to the count of E2 node configuration obtained from the function's caller */
722 if(procedureCode == ProcedureCodeE2_id_E2setup)
723 e2NodeAddList->list.count = duCb.e2apDb.e2NodeComponentList.count;
725 e2NodeAddList->list.count = count;
727 e2NodeAddList->list.size = e2NodeAddList->list.count * sizeof(E2nodeComponentConfigAddition_ItemIEs_t *);
728 DU_ALLOC(e2NodeAddList->list.array, e2NodeAddList->list.size);
729 if(e2NodeAddList->list.array == NULLP)
731 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
735 for(arrIdx = 0; arrIdx< e2NodeAddList->list.count; arrIdx++)
737 DU_ALLOC(e2NodeAddList->list.array[arrIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
738 if(e2NodeAddList->list.array[arrIdx] == NULLP)
740 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
744 if(procedureCode == ProcedureCodeE2_id_E2setup)
746 /* Getting all of the E2 node configuration's information from DuCb one by one*/
749 CM_LLIST_FIRST_NODE(&duCb.e2apDb.e2NodeComponentList, node);
757 DU_LOG("\nERROR --> E2AP : E2 node component list node is null");
760 e2NodeComponentInfo = (E2NodeComponent*)node->node;
764 /* Getting only those E2 node configuration from DuCb whose interface
765 * and action type is present in the received array */
766 e2NodeComponentInfo = fetchE2NodeComponentInfo(e2NodeList[arrIdx].interface, e2NodeList[arrIdx].actionType, &node);
769 if(!e2NodeComponentInfo)
771 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
775 e2NodeAddItemIe = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[arrIdx];
776 e2NodeAddItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition_Item;
777 e2NodeAddItemIe->criticality = CriticalityE2_reject;
778 e2NodeAddItemIe->value.present = E2nodeComponentConfigAddition_ItemIEs__value_PR_E2nodeComponentConfigAddition_Item;
779 e2NodeAddItem = &e2NodeAddItemIe->value.choice.E2nodeComponentConfigAddition_Item;
780 if(fillE2NodeConfig((PTR)e2NodeAddItem, e2NodeComponentInfo, CONFIG_ADD) != ROK)
782 DU_LOG("\nERROR --> E2AP : Failed to fill the E2 node configuration");
789 /*******************************************************************
791 * @brief Builds E2 node config update list
795 * Function : BuildE2NodeConfigUpdateList
797 * Functionality: Building E2 node config update list
800 * E2nodeComponentConfigUpdate_List_t to be filled
801 * Count of E2 node to be update in the list
802 * Received list of E2 node configuration
804 * @return ROK - success
807 ******************************************************************/
809 uint8_t BuildE2NodeConfigUpdateList(E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList, uint16_t count, E2NodeConfigItem *updateE2Node)
813 E2NodeComponent *e2NodeComponentInfo =NULL;
814 E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItemIe =NULL;
815 E2nodeComponentConfigUpdate_Item_t *e2NodeUpdateItem =NULL;
817 e2NodeUpdateList->list.count = count;
818 e2NodeUpdateList->list.size = e2NodeUpdateList->list.count * sizeof(E2nodeComponentConfigUpdate_ItemIEs_t *);
819 DU_ALLOC(e2NodeUpdateList->list.array, e2NodeUpdateList->list.size);
820 if(e2NodeUpdateList->list.array == NULLP)
822 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigUpdateList %d",__LINE__);
826 for(arrIdx = 0; arrIdx< e2NodeUpdateList->list.count; arrIdx++)
828 DU_ALLOC(e2NodeUpdateList->list.array[arrIdx], sizeof(E2nodeComponentConfigUpdate_ItemIEs_t));
829 if(e2NodeUpdateList->list.array[arrIdx] == NULLP)
831 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigUpdateList %d",__LINE__);
835 e2NodeComponentInfo= fetchE2NodeComponentInfo(updateE2Node[arrIdx].interface, updateE2Node[arrIdx].actionType, &node);
836 if(!e2NodeComponentInfo)
838 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
842 e2NodeUpdateItemIe = (E2nodeComponentConfigUpdate_ItemIEs_t *) e2NodeUpdateList->list.array[arrIdx];
843 e2NodeUpdateItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate_Item;
844 e2NodeUpdateItemIe->criticality = CriticalityE2_reject;
845 e2NodeUpdateItemIe->value.present = E2nodeComponentConfigUpdate_ItemIEs__value_PR_E2nodeComponentConfigUpdate_Item;
846 e2NodeUpdateItem = &e2NodeUpdateItemIe->value.choice.E2nodeComponentConfigUpdate_Item;
848 if(fillE2NodeConfig((PTR)e2NodeUpdateItem, e2NodeComponentInfo, CONFIG_MOD) != ROK)
850 DU_LOG("\nERROR --> E2AP : Failed to fill the E2 node configuration");
860 /*******************************************************************
862 * @brief Builds E2 node config remove list
866 * Function :BuildE2NodeConfigRemoveList
868 * Functionality: Building E2 node config remove list
871 * E2nodeComponentConfigRemoval_List_t to be filled
872 * Count of E2 node to be remove in the list
873 * Received list of E2 node configuration
874 * @return ROK - success
877 ******************************************************************/
879 uint8_t BuildE2NodeConfigRemoveList(E2nodeComponentConfigRemoval_List_t *e2NodeRemoveList, uint16_t count, E2NodeConfigItem *updateE2Node)
883 E2NodeComponent *e2NodeComponentInfo=NULL;
884 E2nodeComponentConfigRemoval_ItemIEs_t *e2NodeRemovalItemIe=NULL;
885 E2nodeComponentConfigRemoval_Item_t *e2NodeRemovalItem=NULL;
887 e2NodeRemoveList->list.count = count;
888 e2NodeRemoveList->list.size = e2NodeRemoveList->list.count * sizeof(E2nodeComponentConfigRemoval_ItemIEs_t *);
889 DU_ALLOC(e2NodeRemoveList->list.array, e2NodeRemoveList->list.size);
890 if(e2NodeRemoveList->list.array == NULLP)
892 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigRemoveList %d",__LINE__);
896 for(arrIdx = 0; arrIdx< e2NodeRemoveList->list.count; arrIdx++)
898 DU_ALLOC(e2NodeRemoveList->list.array[arrIdx], sizeof(E2nodeComponentConfigRemoval_ItemIEs_t));
899 if(e2NodeRemoveList->list.array[arrIdx] == NULLP)
901 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigRemoveList %d",__LINE__);
905 e2NodeComponentInfo= fetchE2NodeComponentInfo(updateE2Node[arrIdx].interface, updateE2Node[arrIdx].actionType, &node);
906 if(!e2NodeComponentInfo)
908 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
912 e2NodeRemovalItemIe = (E2nodeComponentConfigRemoval_ItemIEs_t *) e2NodeRemoveList->list.array[arrIdx];
913 e2NodeRemovalItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval_Item;
914 e2NodeRemovalItemIe->criticality = CriticalityE2_reject;
915 e2NodeRemovalItemIe->value.present = E2nodeComponentConfigRemoval_ItemIEs__value_PR_E2nodeComponentConfigRemoval_Item;
916 e2NodeRemovalItem = &e2NodeRemovalItemIe->value.choice.E2nodeComponentConfigRemoval_Item;
918 if(fillE2NodeConfig((PTR)e2NodeRemovalItem, e2NodeComponentInfo, CONFIG_DEL) != ROK)
920 DU_LOG("\nERROR --> E2AP : Failed to fill the E2 node configuration");
927 /*******************************************************************
929 * @brief deallocation of E2SM_KPM_RANfunction_Description_t
933 * Function : freeE2smKpmRanFunctionDefinition
935 * Functionality: deallocation of E2SM_KPM_RANfunction_Description_t
937 * @params[in] E2SM_KPM_RANfunction_Description_t *ranFunctionDefinition
940 ******************************************************************/
942 void freeE2smKpmRanFunctionDefinition(E2SM_KPM_RANfunction_Description_t *ranFunctionDefinition)
944 MeasurementInfo_Action_Item_t *measInfoList;
945 uint8_t eventTriggerIdx, reportStyleIdx, measInfoIdx;
946 RANfunction_Name_t *ranFuncName;
947 struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle;
948 struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List *eventTriggerStyle;
949 if(ranFunctionDefinition)
951 ranFuncName = &ranFunctionDefinition->ranFunction_Name;
952 /* Free RAN function Name */
953 DU_FREE(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size);
954 DU_FREE(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size);
955 DU_FREE(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size);
957 /* Sequence of Event Trigger styles */
958 eventTriggerStyle = ranFunctionDefinition->ric_EventTriggerStyle_List;
959 if(eventTriggerStyle)
961 if(eventTriggerStyle->list.array)
963 for(eventTriggerIdx =0;eventTriggerIdx<eventTriggerStyle->list.count; eventTriggerIdx++)
965 if(eventTriggerStyle->list.array[eventTriggerIdx])
967 DU_FREE(eventTriggerStyle->list.array[eventTriggerIdx]->ric_EventTriggerStyle_Name.buf,\
968 eventTriggerStyle->list.array[eventTriggerIdx]->ric_EventTriggerStyle_Name.size);
969 DU_FREE(eventTriggerStyle->list.array[eventTriggerIdx], sizeof(RIC_EventTriggerStyle_Item_t ));
972 DU_FREE(eventTriggerStyle->list.array, eventTriggerStyle->list.size)
974 DU_FREE(eventTriggerStyle, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List));
977 /* Sequence of Report styles */
978 ricReportStyle = ranFunctionDefinition->ric_ReportStyle_List;
981 if(ricReportStyle->list.array)
983 for(reportStyleIdx =0;reportStyleIdx<ricReportStyle->list.count; reportStyleIdx++)
985 if(ricReportStyle->list.array[reportStyleIdx])
987 if(ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.buf)
989 DU_FREE(ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.buf,\
990 ricReportStyle->list.array[reportStyleIdx]->ric_ReportStyle_Name.size);
992 if(ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.array)
994 for(measInfoIdx=0; measInfoIdx<ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.count; \
997 measInfoList = ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.array[measInfoIdx];
1000 DU_FREE(measInfoList->measID, sizeof(long));
1001 DU_FREE(measInfoList->measName.buf, measInfoList->measName.size);
1002 DU_FREE(measInfoList,sizeof(MeasurementInfo_Action_Item_t));
1005 DU_FREE(measInfoList,ricReportStyle->list.array[reportStyleIdx]->measInfo_Action_List.list.size);
1007 DU_FREE(ricReportStyle->list.array[reportStyleIdx], sizeof(RIC_ReportStyle_Item_t));
1010 DU_FREE(ricReportStyle->list.array, ricReportStyle->list.size);
1012 DU_FREE(ricReportStyle, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List));
1014 DU_FREE(ranFunctionDefinition, sizeof(E2SM_KPM_RANfunction_Description_t));
1018 /*******************************************************************
1020 * @brief fill the e2sm ric report style
1024 * Function : fillRicReportStyle
1026 * Functionality: fill the report style
1028 * @params[in] RanFunction *ranFuncDb, struct
1029 * E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle
1030 * @return ROK - success
1033 ******************************************************************/
1034 uint8_t fillRicReportStyle(RanFunction *ranFuncDb, struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List *ricReportStyle)
1036 uint8_t styleIdx, measInfoIdx;
1037 MeasurementInfo_Action_List_t *measInfo;
1040 ricReportStyle->list.count = ranFuncDb->numOfReportStyleSupported;
1041 ricReportStyle->list.size = ricReportStyle->list.count * sizeof(RIC_ReportStyle_Item_t*);
1042 DU_ALLOC(ricReportStyle->list.array, ricReportStyle->list.size);
1043 if(!ricReportStyle->list.array)
1045 DU_LOG("\nERROR --> E2AP: Memory allocation failed for ranFuncDefinition %d",__LINE__);
1049 for(styleIdx =0;styleIdx<ricReportStyle->list.count; styleIdx++)
1051 DU_ALLOC(ricReportStyle->list.array[styleIdx], sizeof(RIC_ReportStyle_Item_t));
1052 if(!ricReportStyle->list.array[styleIdx])
1054 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1058 /* RIC Report Style Type */
1059 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Type = ranFuncDb->reportStyleList[styleIdx].reportStyle.styleType;
1061 /* RIC Report Style Format Type */
1062 ricReportStyle->list.array[styleIdx]->ric_ActionFormat_Type = ranFuncDb->reportStyleList[styleIdx].reportStyle.formatType;
1064 /* RIC Report Style Name */
1065 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size = strlen(ranFuncDb->reportStyleList[styleIdx].reportStyle.name);
1066 DU_ALLOC(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf,\
1067 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size);
1068 if(!ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf)
1070 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1073 memcpy(ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.buf, ranFuncDb->reportStyleList[styleIdx].reportStyle.name,\
1074 ricReportStyle->list.array[styleIdx]->ric_ReportStyle_Name.size);
1076 /* RIC Indication Header Format Type*/
1077 ricReportStyle->list.array[styleIdx]->ric_IndicationHeaderFormat_Type = ranFuncDb->ricIndicationHeaderFormat;
1079 /* RIC Indication Message Format Type*/
1080 ricReportStyle->list.array[styleIdx]->ric_IndicationMessageFormat_Type = ranFuncDb->ricIndicationMessageFormat;
1082 /* Measurement Info Action List */
1083 CmLListCp measInfoList =ranFuncDb->reportStyleList[styleIdx].measurementInfoList;
1084 if(!measInfoList.count)
1089 CM_LLIST_FIRST_NODE(&ranFuncDb->reportStyleList[styleIdx].measurementInfoList, node);
1090 measInfo = &ricReportStyle->list.array[styleIdx]->measInfo_Action_List;
1092 measInfo->list.count = measInfoList.count;
1093 measInfo->list.size = measInfoList.count*sizeof(MeasurementInfo_Action_Item_t*);
1094 DU_ALLOC(measInfo->list.array, measInfo->list.size);
1095 if(!measInfo->list.array)
1097 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1101 for(measInfoIdx=0; measInfoIdx<measInfo->list.count; measInfoIdx++)
1105 DU_LOG("\nERROR --> E2AP: Measurement info node is null");
1109 DU_ALLOC(measInfo->list.array[measInfoIdx],sizeof(MeasurementInfo_Action_Item_t));
1110 if(!measInfo->list.array[measInfoIdx])
1112 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1115 MeasurementInfoForAction *measInfoForAction= (MeasurementInfoForAction*)node->node;
1116 DU_ALLOC(measInfo->list.array[measInfoIdx]->measID, sizeof(long));
1117 if(!measInfo->list.array[measInfoIdx]->measID)
1119 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1123 memcpy(measInfo->list.array[measInfoIdx]->measID, &measInfoForAction->measurementTypeId,sizeof(long));
1124 measInfo->list.array[measInfoIdx]->measName.size= strlen(measInfoForAction->measurementTypeName);
1125 DU_ALLOC(measInfo->list.array[measInfoIdx]->measName.buf, measInfo->list.array[measInfoIdx]->measName.size);
1126 if(!measInfo->list.array[measInfoIdx]->measName.size)
1128 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1132 memcpy(measInfo->list.array[measInfoIdx]->measName.buf, \
1133 measInfoForAction->measurementTypeName,\
1134 measInfo->list.array[measInfoIdx]->measName.size);
1141 /*******************************************************************
1143 * @brief fill the ric event trigger style
1147 * Function : fillRicEventTriggerStyle
1149 * Functionality: fill the ric event trigger style
1152 * @return ROK - success
1155 ******************************************************************/
1156 uint8_t fillRicEventTriggerStyle(RanFunction *ranFuncDb, struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List *ricEventTriggerStyle)
1160 ricEventTriggerStyle->list.count = ranFuncDb->numOfEventTriggerStyleSupported;
1161 ricEventTriggerStyle->list.size = ricEventTriggerStyle->list.count* sizeof(RIC_EventTriggerStyle_Item_t *);
1162 DU_ALLOC(ricEventTriggerStyle->list.array, ricEventTriggerStyle->list.size);
1163 if(!ricEventTriggerStyle->list.array)
1165 DU_LOG("\nERROR --> E2AP: Memory allocation failed for ric_EventTriggerStyle_List %d",__LINE__);
1169 for(styleIdx =0;styleIdx<ricEventTriggerStyle->list.count; styleIdx++)
1171 DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx], sizeof(RIC_EventTriggerStyle_Item_t ));
1172 if(!ricEventTriggerStyle->list.array[styleIdx])
1174 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1177 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Type = ranFuncDb->eventTriggerStyleList[styleIdx].styleType;
1179 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerFormat_Type = ranFuncDb->eventTriggerStyleList[styleIdx].formatType;
1181 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size = strlen(ranFuncDb->eventTriggerStyleList[styleIdx].name);
1182 DU_ALLOC(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,\
1183 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size);
1184 if(!ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf)
1186 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1189 memcpy(ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.buf,ranFuncDb->eventTriggerStyleList[styleIdx].name,\
1190 ricEventTriggerStyle->list.array[styleIdx]->ric_EventTriggerStyle_Name.size);
1196 /*******************************************************************
1198 * @brief Builds Ran function item
1202 * Function : BuildRanFunctionItem
1204 * Functionality: Building RAN function item
1207 * RAN function item that has to be filled
1208 * Stored RAN Function information
1209 * @return ROK - success
1212 ******************************************************************/
1214 uint8_t BuildRanFunctionItem(RANfunction_Item_t *ranFuncItem, RanFunction *ranFuncDb)
1216 uint8_t ret =RFAILED;
1217 RANfunctionDefinition_t *ranFunctionDefinition;
1218 RANfunction_Name_t *ranFuncName;
1219 asn_enc_rval_t encRetVal;
1220 E2SM_KPM_RANfunction_Description_t *ranFuncDefinition;
1224 /* RAN function Id*/
1225 ranFuncItem->ranFunctionID = ranFuncDb->id;
1227 /* RAN Function Revision*/
1228 ranFuncItem->ranFunctionRevision = ranFuncDb->revisionCounter;
1230 /* RAN function OID*/
1231 ranFuncItem->ranFunctionOID.size = strlen(ranFuncDb->name.serviceModelOID);
1232 DU_ALLOC(ranFuncItem->ranFunctionOID.buf, ranFuncItem->ranFunctionOID.size);
1233 if(!ranFuncItem->ranFunctionOID.buf)
1235 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1238 memcpy(ranFuncItem->ranFunctionOID.buf, ranFuncDb->name.serviceModelOID, ranFuncItem->ranFunctionOID.size);
1240 /* RAN function Definition */
1241 DU_ALLOC(ranFuncDefinition, sizeof(E2SM_KPM_RANfunction_Description_t));
1242 if(!ranFuncDefinition)
1244 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1248 /* RAN function Name */
1249 ranFuncName = &ranFuncDefinition->ranFunction_Name;
1251 /* RAN function ShortName */
1252 ranFuncName->ranFunction_ShortName.size = strlen(ranFuncDb->name.shortName);
1253 DU_ALLOC(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size);
1254 if(!ranFuncName->ranFunction_ShortName.buf)
1256 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1259 memcpy(ranFuncName->ranFunction_ShortName.buf, ranFuncDb->name.shortName, strlen(ranFuncDb->name.shortName));
1261 /* RAN function E2SM_OID */
1262 ranFuncName->ranFunction_E2SM_OID.size = strlen(ranFuncDb->name.serviceModelOID);
1263 DU_ALLOC(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size);
1264 if(!ranFuncName->ranFunction_E2SM_OID.buf)
1266 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1269 memcpy(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncDb->name.serviceModelOID, ranFuncName->ranFunction_E2SM_OID.size);
1271 /* RAN Function Name Description */
1272 ranFuncName->ranFunction_Description.size = strlen(ranFuncDb->name.description);
1273 DU_ALLOC(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size);
1274 if(!ranFuncName->ranFunction_Description.buf)
1276 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1279 memcpy(ranFuncName->ranFunction_Description.buf, ranFuncDb->name.description, ranFuncName->ranFunction_Description.size);
1281 /* RIC Event Trigger Style List */
1282 DU_ALLOC(ranFuncDefinition->ric_EventTriggerStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List));
1283 if(!ranFuncDefinition->ric_EventTriggerStyle_List)
1285 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1289 if(fillRicEventTriggerStyle(ranFuncDb, ranFuncDefinition->ric_EventTriggerStyle_List)!=ROK)
1291 DU_LOG("\nERROR --> E2AP: failed to fill ric event trigger style");
1295 /* RIC Report Style List */
1296 DU_ALLOC(ranFuncDefinition->ric_ReportStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_ReportStyle_List));
1297 if(!ranFuncDefinition->ric_ReportStyle_List)
1299 DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
1302 if(fillRicReportStyle(ranFuncDb, ranFuncDefinition->ric_ReportStyle_List) != ROK)
1304 DU_LOG("\nERROR --> E2AP: failed to fill ric report style");
1308 /* Encode the F1SetupRequest type as APER */
1309 xer_fprint(stdout, &asn_DEF_E2SM_KPM_RANfunction_Description, ranFuncDefinition);
1311 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1313 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_RANfunction_Description, 0, ranFuncDefinition, PrepFinalEncBuf, encBuf);
1315 /* Encode results */
1316 if(encRetVal.encoded == ENCODE_FAIL)
1318 DU_LOG("\nERROR --> F1AP : Could not encode RAN function definition (at %s)\n",\
1319 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1324 DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RAN function definition \n");
1325 for(uint8_t measIeIdx=0; measIeIdx< encBufSize; measIeIdx++)
1327 printf("%x",encBuf[measIeIdx]);
1329 ranFunctionDefinition = &ranFuncItem->ranFunctionDefinition;
1330 ranFunctionDefinition->size = encBufSize;
1331 DU_ALLOC(ranFunctionDefinition->buf, encBufSize);
1332 if(ranFunctionDefinition->buf == NULLP)
1334 DU_LOG("\nERROR --> F1AP : Memory allocation failed for RAN function definition buffer");
1337 memcpy(ranFunctionDefinition->buf, &encBuf, encBufSize);
1342 freeE2smKpmRanFunctionDefinition(ranFuncDefinition);
1346 /*******************************************************************
1348 * @brief Builds Ran function add list based on the procedure code
1352 * Function : BuildRanFunctionAddList
1354 * Functionality: Building RAN addition addition list
1355 * In case of ProcedureCodeE2_id_E2setup we add all the RAN Function list
1356 * which is present in E2 database.
1357 * In the case of other procedures, we just fill the RAN functions whose ID
1358 * is contained in recvList
1363 * Count of ran functions to be added in the list
1364 * Received list of RAN functions
1366 * @return ROK - success
1369 ******************************************************************/
1371 uint8_t BuildRanFunctionAddList(RANfunctions_List_t *ranFunctionsList, uint8_t procedureCode, uint8_t count, RanFuncInfo *recvList)
1374 RanFunction *ranFuncDb;
1376 RANfunction_ItemIEs_t *ranFuncItemIe;
1378 /* For ProcedureCodeE2_id_E2setup, the number of RAN function list items is
1379 * equal to the number of ran function entries stored in the database.
1380 * For any other procedure, the RAN function list count is equal
1381 * to the count of ran functions obtained from the function's caller */
1383 if(procedureCode == ProcedureCodeE2_id_E2setup)
1384 ranFunctionsList->list.count = duCb.e2apDb.numOfRanFunction;
1386 ranFunctionsList->list.count = count;
1388 ranFunctionsList->list.size = ranFunctionsList->list.count * sizeof(RANfunction_ItemIEs_t*);
1389 DU_ALLOC(ranFunctionsList->list.array, ranFunctionsList->list.size);
1390 if(ranFunctionsList->list.array == NULLP)
1392 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
1396 for(ranFuncIdx = 0; ranFuncIdx< ranFunctionsList->list.count; ranFuncIdx++)
1398 DU_ALLOC(ranFunctionsList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
1399 if(ranFunctionsList->list.array[ranFuncIdx] == NULLP)
1401 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
1404 if(procedureCode == ProcedureCodeE2_id_E2setup)
1406 /* Getting all of the RAN function's information from DuCb one by one*/
1407 ranFuncDb = &duCb.e2apDb.ranFunction[ranFuncIdx];
1411 /* Getting only the RAN function information from DuCb whose Id is
1412 * present in the received array */
1413 id =recvList[ranFuncIdx].id;
1414 ranFuncDb = &duCb.e2apDb.ranFunction[id-1];
1416 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
1417 ranFuncItemIe->id = ProtocolIE_IDE2_id_RANfunction_Item;
1418 ranFuncItemIe->criticality = CriticalityE2_ignore;
1419 ranFuncItemIe->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item;
1420 BuildRanFunctionItem(&ranFuncItemIe->value.choice.RANfunction_Item, ranFuncDb);
1425 /*******************************************************************
1427 * @brief De Allocate E2 Setup Request Message
1431 * Function : FreeE2SetupReq
1433 * Functionality: De-Allocating E2 Setup request Message
1435 * @params[in] E2AP_PDU_t *e2apMsg
1439 * ****************************************************************/
1441 void FreeE2SetupReq(E2AP_PDU_t *e2apMsg)
1444 uint8_t e2NodeAddListIdx =0, ranFuncAddListIdx;
1445 E2setupRequest_t *e2SetupReq;
1446 E2nodeComponentConfigAddition_List_t *e2NodeAddList;
1447 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem;
1448 RANfunctions_List_t *ranFunctionsList;
1449 RANfunction_ItemIEs_t *ranFuncItemIe;
1450 RANfunction_Item_t *ranFunItem;
1452 /* De-allocating Memory */
1453 if(e2apMsg != NULLP)
1455 if(e2apMsg->choice.initiatingMessage != NULLP)
1457 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
1458 if(e2SetupReq->protocolIEs.list.array != NULLP)
1460 for(arrIdx = 0; arrIdx < e2SetupReq->protocolIEs.list.count; arrIdx++)
1462 if(e2SetupReq->protocolIEs.list.array[arrIdx] != NULLP)
1464 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
1466 case ProtocolIE_IDE2_id_TransactionID:
1468 case ProtocolIE_IDE2_id_GlobalE2node_ID:
1470 if(e2SetupReq->protocolIEs.list.array[arrIdx]->\
1471 value.choice.GlobalE2node_ID.choice.gNB != NULLP)
1473 GlobalE2node_gNB_ID_t *gNbId = NULLP;
1474 gNbId = e2SetupReq->protocolIEs.list.array[arrIdx]->\
1475 value.choice.GlobalE2node_ID.choice.gNB;
1476 if(gNbId->global_gNB_ID.plmn_id.buf != NULLP)
1478 DU_FREE(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf,\
1479 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
1480 DU_FREE(gNbId->global_gNB_ID.plmn_id.buf,\
1481 gNbId->global_gNB_ID.plmn_id.size);
1484 if(gNbId->gNB_DU_ID != NULLP)
1486 DU_FREE( gNbId->gNB_DU_ID->buf, gNbId->gNB_DU_ID->size);
1487 DU_FREE(gNbId->gNB_DU_ID, sizeof(GNB_DU_ID_t));
1489 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
1490 choice.GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
1494 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
1496 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
1497 if(e2NodeAddList->list.array)
1499 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
1501 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
1503 /* Free E2 Node Component Request Part */
1504 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf,\
1505 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.size);
1507 /* Free E2 Node Component Response Part */
1508 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.\
1509 e2nodeComponentResponsePart.buf, \
1510 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentResponsePart.size);
1512 /* Free E2 Node Component ID */
1513 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1)
1515 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
1516 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
1517 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
1518 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
1519 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
1520 sizeof(E2nodeComponentInterfaceF1_t));
1522 DU_FREE(e2NodeAddList->list.array[e2NodeAddListIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
1524 DU_FREE(e2NodeAddList->list.array, e2NodeAddList->list.size);
1528 case ProtocolIE_IDE2_id_RANfunctionsAdded:
1530 ranFunctionsList = &(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List);
1531 if(ranFunctionsList->list.array)
1533 for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++)
1535 if(ranFunctionsList->list.array[ranFuncAddListIdx])
1537 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx];
1538 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
1539 DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size);
1540 DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size);
1541 DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t));
1544 DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size);
1550 DU_LOG("\nERROR --> E2AP: Invalid event at e2SetupRequet %ld ",\
1551 (e2SetupReq->protocolIEs.list.array[arrIdx]->id));
1554 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx], sizeof(E2setupRequestIEs_t));
1557 DU_FREE(e2SetupReq->protocolIEs.list.array, e2SetupReq->protocolIEs.list.size);
1559 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1561 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1565 /*******************************************************************
1567 * @brief Builds and Send the E2SetupRequest
1571 * Function : BuildAndSendE2SetupReq
1573 * Functionality:Fills the E2SetupRequest
1575 * @return ROK - success
1578 ******************************************************************/
1580 uint8_t BuildAndSendE2SetupReq()
1582 uint8_t arrIdx = 0, elementCnt=0;
1583 uint8_t transId = 0, ret = ROK;
1584 bool memAllocFailed;
1585 E2AP_PDU_t *e2apMsg = NULLP;
1586 E2setupRequest_t *e2SetupReq = NULLP;
1587 asn_enc_rval_t encRetVal; /* Encoder return value */
1589 DU_LOG("\nINFO --> E2AP : Building E2 Setup Request\n");
1592 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1593 if(e2apMsg == NULLP)
1595 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1598 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
1599 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1600 if(e2apMsg->choice.initiatingMessage == NULLP)
1602 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1605 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
1606 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2setup;
1607 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2setupRequest;
1608 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
1611 e2SetupReq->protocolIEs.list.count = elementCnt;
1612 e2SetupReq->protocolIEs.list.size = elementCnt * sizeof(E2setupRequestIEs_t*);
1614 /* Initialize the E2Setup members */
1615 DU_ALLOC(e2SetupReq->protocolIEs.list.array, \
1616 e2SetupReq->protocolIEs.list.size);
1617 if(e2SetupReq->protocolIEs.list.array == NULLP)
1619 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
1622 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
1624 DU_ALLOC(e2SetupReq->protocolIEs.list.array[arrIdx],\
1625 sizeof(E2setupRequestIEs_t));
1626 if(e2SetupReq->protocolIEs.list.array[arrIdx] == NULLP)
1628 memAllocFailed = true;
1629 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayarrIdx [%d]", arrIdx);
1633 if(memAllocFailed == true)
1639 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1640 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1641 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
1642 transId = assignTransactionId();
1643 e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
1646 /* GlobalE2node_gNB_ID */
1647 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_GlobalE2node_ID;
1648 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1649 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID;
1650 e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB;
1652 DU_ALLOC(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
1653 GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
1654 if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
1655 GlobalE2node_ID.choice.gNB == NULLP)
1657 DU_LOG("\nERROR --> E2AP : Memory allocation failed for gNbId");
1662 ret = BuildGlobalgNBId(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
1663 choice.GlobalE2node_ID.choice.gNB);
1666 DU_LOG("\nERROR --> E2AP : Failed to build Global Gnb Id");
1671 /* RAN Functions Added List */
1673 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded;
1674 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1675 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_RANfunctions_List;
1676 if(BuildRanFunctionAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List), ProcedureCodeE2_id_E2setup, 0, NULL)!=ROK)
1678 DU_LOG("\nERROR --> E2AP : Failed to create RAN Function");
1682 /* E2 Node Component Configuration Addition List */
1684 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition;
1685 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1686 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_E2nodeComponentConfigAddition_List;
1687 if(BuildE2NodeConfigAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List), ProcedureCodeE2_id_E2setup, 0, NULL)!=ROK)
1689 DU_LOG("\nERROR --> E2AP : Failed to create E2 Node config list");
1695 /* Prints the Msg formed */
1696 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1698 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1700 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1702 if(encRetVal.encoded == ENCODE_FAIL)
1704 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\
1705 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1710 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n");
1711 #ifdef DEBUG_ASN_PRINT
1712 for(int i=0; i< encBufSize; i++)
1714 printf("%x",encBuf[i]);
1718 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
1720 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
1725 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
1726 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
1728 FreeE2SetupReq(e2apMsg);
1730 }/* End of BuildAndSendE2SetupReq */
1732 /*******************************************************************
1734 * @brief Builds RIC Action Admitted List
1738 * Function : BuildRicActionAdmitList
1740 * Functionality: Builds RIC Action Admitted List
1742 * @params[in] Pointer to RIC Action Admitted List to be filled
1743 * Subscription Response information
1744 * @return ROK - success
1747 * ****************************************************************/
1748 uint8_t BuildRicActionAdmitList(RICaction_Admitted_List_t *admitList, PendingSubsRspInfo *subsRspInfo)
1751 uint8_t elementCnt = 0;
1752 RICaction_Admitted_ItemIEs_t *admitItem = NULLP;
1754 elementCnt = subsRspInfo->numOfAcceptedActions;
1756 admitList->list.count = elementCnt;
1757 admitList->list.size = elementCnt * sizeof(RICaction_Admitted_ItemIEs_t *);
1759 DU_ALLOC(admitList->list.array, admitList->list.size);
1760 if(admitList->list.array == NULLP)
1762 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1766 for(idx=0; idx<elementCnt; idx++)
1768 DU_ALLOC(admitList->list.array[idx], sizeof(RICaction_Admitted_ItemIEs_t));
1769 if(admitList->list.array[idx] == NULLP)
1771 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1775 admitItem = (RICaction_Admitted_ItemIEs_t *)admitList->list.array[idx];
1776 admitItem->id = ProtocolIE_IDE2_id_RICaction_Admitted_Item;
1777 admitItem->criticality = CriticalityE2_reject;
1778 admitItem->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
1779 admitItem->value.choice.RICaction_Admitted_Item.ricActionID = subsRspInfo->acceptedActionList[idx];
1784 /*******************************************************************
1786 * @brief Builds RIC Action Not Admitted List
1790 * Function : BuildRicActionNotAdmitList
1792 * Functionality: Builds RIC Action Not Admitted List
1794 * @params[in] Pointer to RIC Action Not Admitted List to be filled
1795 * Subscription Response information
1796 * @return ROK - success
1799 * ****************************************************************/
1800 uint8_t BuildRicActionNotAdmitList(RICaction_NotAdmitted_List_t *notAdmitList, PendingSubsRspInfo *subsRspInfo)
1803 uint8_t elementCnt = 0;
1804 RICaction_NotAdmitted_ItemIEs_t *notAdmitItem = NULLP;
1806 elementCnt = subsRspInfo->numOfRejectedActions;
1808 notAdmitList->list.count = elementCnt;
1809 notAdmitList->list.size = elementCnt * sizeof(RICaction_NotAdmitted_ItemIEs_t *);
1811 DU_ALLOC(notAdmitList->list.array, notAdmitList->list.size);
1812 if(notAdmitList->list.array == NULLP)
1814 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1818 for(idx=0; idx<elementCnt; idx++)
1820 DU_ALLOC(notAdmitList->list.array[idx], sizeof(RICaction_NotAdmitted_ItemIEs_t));
1821 if(notAdmitList->list.array[idx] == NULLP)
1823 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__);
1827 notAdmitItem = (RICaction_NotAdmitted_ItemIEs_t *)notAdmitList->list.array[idx];
1828 notAdmitItem->id = ProtocolIE_IDE2_id_RICaction_NotAdmitted_Item;
1829 notAdmitItem->criticality = CriticalityE2_reject;
1830 notAdmitItem->value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;
1831 notAdmitItem->value.choice.RICaction_NotAdmitted_Item.ricActionID = \
1832 subsRspInfo->rejectedActionList[idx].id;
1833 fillE2Cause(¬AdmitItem->value.choice.RICaction_NotAdmitted_Item.cause, \
1834 subsRspInfo->rejectedActionList[idx].failureCause);
1839 /*******************************************************************
1841 * @breif Deallocation of BuildAndSendRicSubscriptionRsp memory
1845 * Function : FreeRicSubscriptionRsp
1847 * Functionality:Free the RicSubscriptionRsp
1849 * @param[in] E2AP_PDU_t *e2apRicMsg
1853 ******************************************************************/
1854 void FreeRicSubscriptionRsp(E2AP_PDU_t *e2apRicMsg)
1856 RICsubscriptionResponse_t *ricSubscriptionRsp= NULLP;
1859 RICaction_Admitted_List_t *admitList = NULLP;
1860 RICaction_NotAdmitted_List_t *notAdmitList = NULLP;
1862 if(e2apRicMsg != NULLP)
1864 if(e2apRicMsg->choice.successfulOutcome != NULLP)
1866 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
1867 if(ricSubscriptionRsp)
1869 if(ricSubscriptionRsp->protocolIEs.list.array != NULLP)
1871 for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
1873 if(ricSubscriptionRsp->protocolIEs.list.array[idx] != NULLP)
1875 switch(ricSubscriptionRsp->protocolIEs.list.array[idx]->id)
1877 case ProtocolIE_IDE2_id_RICactions_Admitted:
1879 admitList = &ricSubscriptionRsp->protocolIEs.list.\
1880 array[idx]->value.choice.RICaction_Admitted_List;
1881 if(admitList->list.array != NULLP)
1883 for(listIdx=0 ; listIdx < admitList->list.count; listIdx++)
1885 DU_FREE(admitList->list.array[listIdx], sizeof(RICaction_Admitted_ItemIEs_t));
1887 DU_FREE(admitList->list.array, admitList->list.size);
1891 case ProtocolIE_IDE2_id_RICactions_NotAdmitted:
1893 notAdmitList = &ricSubscriptionRsp->protocolIEs.list.\
1894 array[idx]->value.choice.RICaction_NotAdmitted_List;
1895 if(notAdmitList->list.array != NULLP)
1897 for(listIdx=0 ; listIdx < notAdmitList->list.count; listIdx++)
1899 DU_FREE(notAdmitList->list.array[listIdx], sizeof(RICaction_NotAdmitted_ItemIEs_t));
1901 DU_FREE(notAdmitList->list.array, notAdmitList->list.size);
1908 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array[idx], sizeof(RICsubscriptionResponse_IEs_t));
1911 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array, ricSubscriptionRsp->protocolIEs.list.size);
1914 DU_FREE(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1916 DU_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
1920 /*******************************************************************
1922 * @brief Fill RIC Subscription Response IEs
1926 * Function : fillRicSubscriptionRsp
1928 * functionality: Fill RIC Subscription Response IEs
1930 * @param Pointer to RIC subscription response
1931 * Subscription response information
1932 * @return ROK - success
1935 ******************************************************************/
1936 uint8_t fillRicSubscriptionRsp(RICsubscriptionResponse_t *ricSubscriptionRsp, PendingSubsRspInfo *subsRspInfo)
1939 uint8_t elementCnt = 0;
1940 RICsubscriptionResponse_IEs_t *subsRspIe = NULLP;
1943 if(subsRspInfo->numOfRejectedActions)
1946 ricSubscriptionRsp->protocolIEs.list.count = elementCnt;
1947 ricSubscriptionRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionResponse_IEs_t);
1948 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array, ricSubscriptionRsp->protocolIEs.list.size);
1949 if(ricSubscriptionRsp->protocolIEs.list.array == NULLP)
1951 DU_LOG("\nERROR --> E2AP : Memory allocation failed at %s : line %d", __func__, __LINE__);
1955 for(ieIdx=0; ieIdx<ricSubscriptionRsp->protocolIEs.list.count; ieIdx++)
1957 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionResponse_IEs_t));
1958 if(ricSubscriptionRsp->protocolIEs.list.array[ieIdx] == NULLP)
1960 DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d] : ieIdx [%d]", __func__, __LINE__,ieIdx);
1965 /* RIC Request ID */
1967 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
1968 subsRspIe->id = ProtocolIE_IDE2_id_RICrequestID;
1969 subsRspIe->criticality = CriticalityE2_reject;
1970 subsRspIe->value.present = RICsubscriptionRequest_IEs__value_PR_RICrequestID;
1971 subsRspIe->value.choice.RICrequestID.ricRequestorID = subsRspInfo->requestId.requestorId;
1972 subsRspIe->value.choice.RICrequestID.ricInstanceID = subsRspInfo->requestId.instanceId;
1974 /* RAN Function ID */
1976 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
1977 subsRspIe->id = ProtocolIE_IDE2_id_RANfunctionID;
1978 subsRspIe->criticality = CriticalityE2_reject;
1979 subsRspIe->value.present = RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
1980 subsRspIe->value.choice.RANfunctionID = subsRspInfo->ranFuncId;
1982 /* RIC Action Admitted List */
1984 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
1985 subsRspIe->id = ProtocolIE_IDE2_id_RICactions_Admitted;
1986 subsRspIe->criticality = CriticalityE2_reject;
1987 subsRspIe->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
1988 if(BuildRicActionAdmitList(&subsRspIe->value.choice.RICaction_Admitted_List, subsRspInfo) != ROK)
1990 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Action Admitted List in RIC Subscription Response");
1994 /* RIC Action Not Admitted List */
1995 if(subsRspInfo->numOfRejectedActions)
1998 subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx];
1999 subsRspIe->id = ProtocolIE_IDE2_id_RICactions_NotAdmitted;
2000 subsRspIe->criticality = CriticalityE2_reject;
2001 subsRspIe->criticality = CriticalityE2_reject;
2002 subsRspIe->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List;
2003 if(BuildRicActionNotAdmitList(&subsRspIe->value.choice.RICaction_NotAdmitted_List, subsRspInfo) != ROK)
2005 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Action Not Admitted List in RIC Subscription Response");
2013 /*******************************************************************
2015 * @brief Builds and Send the RicSubscriptionRsp
2019 * Function : BuildAndSendRicSubscriptionRsp
2021 * Functionality:Fills the RicSubscriptionRsp
2023 * @return ROK - success
2026 ******************************************************************/
2028 uint8_t BuildAndSendRicSubscriptionRsp(PendingSubsRspInfo *subsRspInfo)
2030 uint8_t ret = RFAILED;
2031 E2AP_PDU_t *e2apRicMsg = NULLP;
2032 RICsubscriptionResponse_t *ricSubscriptionRsp=NULLP;
2033 asn_enc_rval_t encRetVal;
2037 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Response\n");
2039 DU_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
2040 if(e2apRicMsg == NULLP)
2042 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2046 e2apRicMsg->present = E2AP_PDU_PR_successfulOutcome;
2047 DU_ALLOC(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
2048 if(e2apRicMsg->choice.successfulOutcome == NULLP)
2050 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC subscription Response failed");
2054 e2apRicMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
2055 e2apRicMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
2056 e2apRicMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse;
2058 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
2060 if(fillRicSubscriptionRsp(ricSubscriptionRsp, subsRspInfo) != ROK)
2062 DU_LOG("\nERROR --> E2AP : Memory allocation for RICsubscriptionResponseIE failed");
2066 /* Prints the Msg formed */
2067 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
2069 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2071 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf);
2072 if(encRetVal.encoded == ENCODE_FAIL)
2074 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
2075 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2080 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription response \n");
2081 #ifdef DEBUG_ASN_PRINT
2082 for(int i=0; i< encBufSize; i++)
2084 printf("%x",encBuf[i]);
2089 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
2091 DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Response failed");
2100 FreeRicSubscriptionRsp(e2apRicMsg);
2104 /******************************************************************
2106 * @brief Deallocation of memory allocated by aper decoder for e2 setup response
2110 * Function : freeAperDecodingOfE2SetupRsp
2112 * Functionality: Deallocation of memory allocated by aper decoder for e2
2115 * @params[in] E2setupResponse_t *e2SetRspMsg;
2118 * ****************************************************************/
2119 void freeAperDecodingOfE2SetupRsp(E2setupResponse_t *e2SetRspMsg)
2121 uint8_t arrIdx, e2NodeConfigAddAckListIdx;
2122 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem;
2123 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAddAckList;
2127 if(e2SetRspMsg->protocolIEs.list.array)
2129 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
2131 if(e2SetRspMsg->protocolIEs.list.array[arrIdx])
2133 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
2135 case ProtocolIE_IDE2_id_TransactionID:
2138 case ProtocolIE_IDE2_id_GlobalRIC_ID:
2140 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.pLMN_Identity.buf);
2141 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID.buf);
2145 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2147 e2NodeConfigAddAckList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
2148 if(e2NodeConfigAddAckList->list.array )
2150 for(e2NodeConfigAddAckListIdx = 0; e2NodeConfigAddAckListIdx< e2NodeConfigAddAckList->list.count; e2NodeConfigAddAckListIdx++)
2152 if(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx])
2154 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx];
2155 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
2156 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf);
2157 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
2158 e2nodeComponentInterfaceTypeF1);
2159 free(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx]);
2162 free(e2NodeConfigAddAckList->list.array);
2167 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]);
2170 free(e2SetRspMsg->protocolIEs.list.array);
2174 /******************************************************************
2176 * @brief Processes E2 Setup Response sent by RIC
2180 * Function : procE2SetupRsp
2182 * Functionality: Processes E2 Setup Response sent by RIC
2184 * @params[in] E2AP_PDU_t ASN decoded E2AP message
2187 * ****************************************************************/
2189 void procE2SetupRsp(E2AP_PDU_t *e2apMsg)
2191 bool invalidTransId = false;
2192 uint8_t arrIdx =0, transId=0, idx=0;
2193 uint32_t recvBufLen;
2194 E2setupResponse_t *e2SetRspMsg=NULL;
2196 E2NodeComponent *e2NodeComponentInfo=NULL;
2197 E2nodeComponentConfigAdditionAck_List_t *e2NodeCfgAckList=NULL;
2198 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem=NULL;
2200 DU_LOG("\nINFO --> E2AP : E2 Setup Response received");
2201 duCb.e2Status = TRUE; //Set E2 status as true
2202 e2SetRspMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
2204 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
2206 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
2208 case ProtocolIE_IDE2_id_TransactionID:
2210 transId = e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
2211 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
2212 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
2214 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
2218 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
2219 invalidTransId = true;
2224 case ProtocolIE_IDE2_id_GlobalRIC_ID:
2226 /* To store the Ric Id Params */
2227 recvBufLen = sizeof(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value\
2228 .choice.GlobalRIC_ID.pLMN_Identity.size);
2229 memcpy(&duCb.e2apDb.ricId.plmnId, e2SetRspMsg->protocolIEs.list.array[arrIdx]\
2230 ->value.choice.GlobalRIC_ID.pLMN_Identity.buf, recvBufLen);
2231 bitStringToInt(&e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID, &duCb.e2apDb.ricId);
2232 /*TODO : duCb.e2apDb.ricId.plmnId memory to be deallocated after the usage */
2236 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
2238 e2NodeCfgAckList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
2239 for(idx =0; idx <e2NodeCfgAckList->list.count; idx++)
2241 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeCfgAckList->list.array[idx];
2242 switch(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.present)
2244 case E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1:
2246 e2NodeComponentInfo = fetchE2NodeComponentInfo(F1, E2_NODE_COMPONENT_ADD, &node);
2247 if(!e2NodeComponentInfo)
2249 DU_LOG("\nERROR --> E2AP : Received null e2NodeComponentInfo at line number %d",__LINE__);
2253 cmLListDelFrm(&duCb.e2apDb.e2NodeComponentList, node);
2254 DU_FREE(e2NodeComponentInfo->componentRequestPart, e2NodeComponentInfo->reqBufSize);
2255 DU_FREE(e2NodeComponentInfo->componentResponsePart, e2NodeComponentInfo->rspBufSize);
2256 DU_FREE(e2NodeComponentInfo, sizeof(E2NodeComponent));
2257 DU_FREE(node, sizeof(CmLList));
2270 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2SetupRsp:%ld",
2271 e2SetRspMsg->protocolIEs.list.array[arrIdx]->id);
2276 if(invalidTransId == true)
2281 freeAperDecodingOfE2SetupRsp(e2SetRspMsg);
2283 if(invalidTransId == false)
2285 if(duSendE2NodeConfigurationUpdate() != ROK)
2287 DU_LOG("\nERROR --> E2AP : Failed to send E2 node config update");
2292 /*******************************************************************
2294 * @brief Free RIC Subscription Request
2298 * Function : freeAperDecodingOfRicSubsReq
2300 * Functionality : Free RIC Subscription Request
2304 ******************************************************************/
2305 void freeAperDecodingOfRicSubsReq(RICsubscriptionRequest_t *ricSubscriptionReq)
2308 uint8_t elementIdx = 0;
2309 RICsubscriptionDetails_t *subsDetails = NULLP;
2310 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
2312 if(ricSubscriptionReq->protocolIEs.list.array)
2314 for(idx=0; idx < ricSubscriptionReq->protocolIEs.list.count; idx++)
2316 switch(ricSubscriptionReq->protocolIEs.list.array[idx]->id)
2318 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
2320 subsDetails = &(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails);
2321 free(subsDetails->ricEventTriggerDefinition.buf);
2323 if(subsDetails->ricAction_ToBeSetup_List.list.array)
2325 for(elementIdx = 0; elementIdx < subsDetails->ricAction_ToBeSetup_List.list.count; elementIdx++)
2327 if(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx])
2329 actionItem = (RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx];
2330 if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
2332 free(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf);
2333 free(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition);
2335 free(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx]);
2338 free(subsDetails->ricAction_ToBeSetup_List.list.array);
2343 free(ricSubscriptionReq->protocolIEs.list.array[idx]);
2345 free(ricSubscriptionReq->protocolIEs.list.array);
2349 /*******************************************************************
2351 * @brief Free Event Trigger Definition
2355 * Function : freeAperDecodingOfEventTriggerDef
2357 * Functionality: Free Event Trigger Definition
2359 * @params[in] E2SM-KPM Event Trigger Definition
2362 * ****************************************************************/
2363 void freeAperDecodingOfEventTriggerDef(E2SM_KPM_EventTriggerDefinition_t *eventTiggerDef)
2367 switch(eventTiggerDef->eventDefinition_formats.present)
2369 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING:
2372 case E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1:
2373 free(eventTiggerDef->eventDefinition_formats.choice.eventDefinition_Format1);
2379 /*******************************************************************
2381 * @brief Extract E2SM-KPM Event trigger definition
2385 * Function : extractEventTriggerDef
2387 * Functionality : This function :
2388 * - Decodes E2SM-KPM Event Trigger Definition
2389 * - Validates that even trigger style is supported by E2 node
2390 * - Stores event trigger details in local DB
2392 * @params[in] RAN Function Database structure
2393 * RIC Subscription Info to be added to RAN function
2394 * RIC Event Trigger Definition buffer received from RIC
2395 * @return ROK - success
2398 ******************************************************************/
2399 uint8_t extractEventTriggerDef(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
2400 RICeventTriggerDefinition_t *ricEventTriggerDef, E2FailureCause *failureCause)
2402 uint8_t ret = RFAILED;
2403 uint8_t eventIdx = 0;
2404 asn_dec_rval_t rval ={0};
2405 E2SM_KPM_EventTriggerDefinition_t eventTiggerDef, *eventTiggerDefPtr = NULLP;
2407 /* Decoding E2SM-KPM Even Trigger Definition */
2408 eventTiggerDefPtr = &eventTiggerDef;
2409 memset(eventTiggerDefPtr, 0, sizeof(E2SM_KPM_EventTriggerDefinition_t));
2411 rval = aper_decode(0, &asn_DEF_E2SM_KPM_EventTriggerDefinition, (void **)&eventTiggerDefPtr, ricEventTriggerDef->buf,\
2412 ricEventTriggerDef->size, 0, 0);
2413 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2415 DU_LOG("\nERROR --> E2AP : ASN decode failed for E2SM-KPM Event Trigger Definition");
2416 failureCause->causeType = E2_PROTOCOL;
2417 failureCause->cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
2421 xer_fprint(stdout, &asn_DEF_E2SM_KPM_EventTriggerDefinition, eventTiggerDefPtr);
2423 /* Validating the received event trigger definition format */
2424 for(eventIdx = 0; eventIdx < ranFuncDb->numOfEventTriggerStyleSupported; eventIdx++)
2426 if((eventTiggerDefPtr->eventDefinition_formats.present != \
2427 E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_NOTHING) && \
2428 (eventTiggerDefPtr->eventDefinition_formats.present == ranFuncDb->eventTriggerStyleList[eventIdx].formatType))
2430 ricSubscriptionInfo->eventTriggerDefinition.formatType = ranFuncDb->eventTriggerStyleList[eventIdx].formatType;
2431 ricSubscriptionInfo->eventTriggerDefinition.choice.format1.reportingPeriod = \
2432 eventTiggerDefPtr->eventDefinition_formats.choice.eventDefinition_Format1->reportingPeriod;
2441 failureCause->causeType = E2_RIC_REQUEST;
2442 failureCause->cause = E2_EVENT_TRIGGER_NOT_SUPPORTED;
2444 /* Free E2SM_KPM_EventTriggerDefinition_t */
2445 freeAperDecodingOfEventTriggerDef(eventTiggerDefPtr);
2449 /*******************************************************************
2451 * @brief Free RIC Action Definition
2455 * Function : freeAperDecodingOfRicActionDefinition
2457 * Functionality: Free RIC Action Definition
2459 * @params[in] E2SM-KPM Action definition
2462 * ****************************************************************/
2463 void freeAperDecodingOfRicActionDefinition(E2SM_KPM_ActionDefinition_t *actionDef)
2465 uint8_t elementIdx = 0;
2466 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
2467 MeasurementInfoItem_t *measItem = NULLP;
2469 switch(actionDef->actionDefinition_formats.present)
2471 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
2473 if(actionDef->actionDefinition_formats.choice.actionDefinition_Format1)
2475 actionFormat1 = actionDef->actionDefinition_formats.choice.actionDefinition_Format1;
2476 if(actionFormat1->measInfoList.list.array)
2478 for(elementIdx = 0; elementIdx < actionFormat1->measInfoList.list.count; elementIdx++)
2480 if(actionFormat1->measInfoList.list.array[elementIdx])
2482 measItem = actionFormat1->measInfoList.list.array[elementIdx];
2483 switch(measItem->measType.present)
2485 case MeasurementType_PR_NOTHING:
2488 case MeasurementType_PR_measName:
2490 free(measItem->measType.choice.measName.buf);
2494 case MeasurementType_PR_measID:
2500 free(actionFormat1->measInfoList.list.array);
2502 free(actionFormat1);
2506 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format2:
2507 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format3:
2508 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format4:
2509 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format5:
2515 /*******************************************************************
2517 * @brief Extract Measurement Info list from action definition
2521 * Function : extractMeasInfoList
2523 * Functionality : This function :
2524 * - Traverses Measurement-to-be-subscribed list
2525 * - Validates that each measurement in Measurement-to-be-subscribed
2526 * list is supported in RAN-Function->Measurement-supported list.
2527 * - If all measurements in an action is supported by RAN function,
2528 * it is added to measurement-subscribed list in local DB
2530 * @params[in] Measurement Info supported list by RAN function
2531 * Measurement Info to be subscribed as requested by RIC
2532 * Measurement Info finally subscribed
2533 * Memory failure indicator
2534 * @return ROK - success
2537 ******************************************************************/
2538 uint8_t extractMeasInfoList(CmLListCp *measInfoSupportedList, MeasurementInfoList_t *measInfoToBeSubscribedList, \
2539 CmLListCp *measInfoSubscribedList, bool *memFailure)
2541 uint8_t elementIdx = 0;
2542 MeasurementInfoForAction *measInfoSupportedDb = NULLP;
2543 MeasurementInfo *measInfoSubscribedDb = NULLP;
2544 CmLList *supportedMeasNode = NULLP, *measToAddNode = NULLP;
2545 MeasurementInfoItem_t *measItem = NULLP;
2547 /* Validate Measurement list is supported by E2 node.
2549 * Traverse and compare the Measurement-Supported List in E2
2550 * node with Measurement-to-be-subscribed list received from RIC.
2551 * If a match is found, add it to measurement-subscription list.
2553 for(elementIdx = 0; elementIdx < measInfoToBeSubscribedList->list.count; elementIdx++)
2555 measInfoSubscribedDb = NULLP;
2556 measToAddNode = NULLP;
2557 measItem = measInfoToBeSubscribedList->list.array[elementIdx];
2559 CM_LLIST_FIRST_NODE(measInfoSupportedList, supportedMeasNode);
2560 while(supportedMeasNode)
2562 measInfoSupportedDb = (MeasurementInfoForAction*)supportedMeasNode->node;
2563 switch(measItem->measType.present)
2565 case MeasurementType_PR_measName:
2567 if(!strcmp(measInfoSupportedDb->measurementTypeName, (char *)measItem->measType.choice.measName.buf))
2569 DU_ALLOC(measInfoSubscribedDb, sizeof(MeasurementInfo));
2574 case MeasurementType_PR_measID:
2576 if(measInfoSupportedDb->measurementTypeId == measItem->measType.choice.measID)
2578 DU_ALLOC(measInfoSubscribedDb, sizeof(MeasurementInfo));
2585 DU_LOG("\nERROR -> DUAPP: Invalid Measurement-type identifier in \
2586 E2SM-KPM Action Definition Format");
2589 } /* End of switch, for measurement type identifier */
2591 /* If measurement type is supported, add to measurement-subscription list */
2592 if(measInfoSubscribedDb)
2594 measInfoSubscribedDb->measurementTypeId = measInfoSupportedDb->measurementTypeId;
2595 memcpy(measInfoSubscribedDb->measurementTypeName, measInfoSupportedDb->measurementTypeName, \
2596 strlen(measInfoSupportedDb->measurementTypeName));
2598 DU_ALLOC(measToAddNode, sizeof(CmLList));
2601 measToAddNode->node = (PTR) measInfoSubscribedDb;
2602 cmLListAdd2Tail(measInfoSubscribedList, measToAddNode);
2604 /* Break out of while loop if measurement info is found in measurement-supported list */
2609 DU_FREE(measInfoSubscribedDb, sizeof(MeasurementInfo));
2610 measInfoSubscribedDb = NULLP;
2616 supportedMeasNode = supportedMeasNode->next;
2618 } /* End of while for traversing measurement-supported list in a report style */
2620 /* If a measurement-to-be-subscribed is not found in measurement-supported list in this report style
2622 * Delete all entries from measurement-subscription list and
2623 * Break out of for loop to search in next report style */
2624 if(!measInfoSubscribedDb)
2626 deleteMeasurementInfoList(measInfoSubscribedList);
2630 } /* End of for loop , traversing measurement-to-be-subscribed list */
2632 /* If all measurement-to-be-subscribed was found in measurement-supported list and
2633 * was added to measurement-subscription list successfully, return from here */
2634 if(measInfoToBeSubscribedList->list.count == measInfoSubscribedList->count)
2640 /*******************************************************************
2642 * @brief Extract E2SM-KPM Action definition
2646 * Function : extractRicActionDef
2648 * Functionality : This function :
2649 * - Decodes E2SM-KPM Action Definition
2650 * - Validates that action is supported by E2 node
2651 * - Stores action details in local DB
2653 * @params[in] RAN Function Database structure
2654 * RIC subscription's Action definition to be added to
2656 * RIC Action Definition buffer received from RIC
2657 * @return ROK - success
2660 ******************************************************************/
2661 uint8_t extractRicActionDef(RanFunction *ranFuncDb, ActionDefinition *actionDefDb, RICactionDefinition_t *ricActionDef,\
2662 E2FailureCause *failureCause)
2664 bool memFailure = false;
2665 uint8_t styleIdx = 0;
2666 asn_dec_rval_t rval ={0};
2668 E2SM_KPM_ActionDefinition_t actionDef, *actionDefPtr = NULLP;
2669 E2SM_KPM_ActionDefinition_Format1_t *actionFormat1 = NULLP;
2670 CmLListCp *measInfoSupportedList = NULLP;
2671 CmLListCp *measInfoSubscribedList = NULLP;
2673 /* Decoding E2SM-KPM Action Definition */
2674 actionDefPtr = &actionDef;
2675 memset(actionDefPtr, 0, sizeof(E2SM_KPM_EventTriggerDefinition_t));
2677 rval = aper_decode(0, &asn_DEF_E2SM_KPM_ActionDefinition, (void **)&actionDefPtr, ricActionDef->buf,\
2678 ricActionDef->size, 0, 0);
2679 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2681 DU_LOG("\nERROR --> E2AP : ASN decode failed for E2SM-KPM Action Definition");
2682 failureCause->causeType = E2_PROTOCOL;
2683 failureCause->cause = E2_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE;
2687 xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, actionDefPtr);
2690 /* Validate if Report style to subscribe is supported by E2 Node */
2691 for(styleIdx= 0; styleIdx < ranFuncDb->numOfReportStyleSupported; styleIdx++)
2693 /* Validate Report style type and report style format type is supported by E2 Node */
2694 if((ranFuncDb->reportStyleList[styleIdx].reportStyle.styleType == actionDefPtr->ric_Style_Type) &&
2695 (ranFuncDb->reportStyleList[styleIdx].reportStyle.formatType == actionDefPtr->actionDefinition_formats.present))
2697 /* Fetch Report stype type and format type */
2698 actionDefDb->styleType = actionDefPtr->ric_Style_Type;
2699 actionDefDb->formatType = actionDefPtr->actionDefinition_formats.present;
2701 switch(actionDefPtr->actionDefinition_formats.present)
2703 case E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1:
2705 actionFormat1 = actionDefPtr->actionDefinition_formats.choice.actionDefinition_Format1;
2707 /* Fetch granularity period */
2708 actionDefDb->choice.format1.granularityPeriod = actionFormat1->granulPeriod;
2710 /* Validate and add the Measurement to subscription list */
2711 measInfoSupportedList = &ranFuncDb->reportStyleList[styleIdx].measurementInfoList;
2712 measInfoSubscribedList = &actionDefDb->choice.format1.measurementInfoList;
2713 if(extractMeasInfoList(measInfoSupportedList, &actionFormat1->measInfoList, \
2714 measInfoSubscribedList, &memFailure) == ROK)
2718 /* Free E2SM_KPM_ActionDefinition_t */
2719 freeAperDecodingOfRicActionDefinition(actionDefPtr);
2724 break; /* End of E2SM-KPM Action definition format 1 case */
2729 DU_LOG("\nERROR -> DUAPP: Only E2SM-KPM Action Definition Format 1 is supported");
2732 } /* End of switch for E2SM-KPM Action definition formats */
2737 failureCause->causeType = E2_MISCELLANEOUS;
2738 failureCause->cause = E2_MISCELLANEOUS_CAUSE_UNSPECIFIED;
2741 } /* End of for loop, traversing Report-styles-supported list in E2 node */
2743 /* Memset action Db and Free E2SM_KPM_ActionDefinition_t */
2744 memset(actionDefDb, 0, sizeof(ActionDefinition));
2745 freeAperDecodingOfRicActionDefinition(actionDefPtr);
2747 if(failureCause->causeType == E2_NOTHING)
2749 failureCause->causeType = E2_RIC_REQUEST;
2750 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
2755 /*******************************************************************
2757 * @brief Extract RIC Action to be setup
2761 * Function : extractRicActionToBeSetup
2763 * Functionality : This function :
2764 * - Validates that each action-to-be-setup is supported by E2 node
2765 * - Stores event trigger details in local DB
2767 * @params[in] RAN Function Database structure
2768 * RIC Subscription Info to be added to RAN function
2769 * RIC Action To Be Setup List received from RIC
2770 * @return ROK - success
2773 ******************************************************************/
2774 uint8_t extractRicActionToBeSetup(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \
2775 RICactions_ToBeSetup_List_t *actionList, E2FailureCause *failureCause, PendingSubsRspInfo *subsRsp)
2777 uint8_t actionIdx = 0;
2778 uint8_t ricActionId = 0;
2779 RICaction_ToBeSetup_ItemIEs_t *actionItem = NULLP;
2781 if(actionList->list.array)
2783 for(actionIdx = 0; actionIdx < actionList->list.count; actionIdx++)
2785 actionItem =(RICaction_ToBeSetup_ItemIEs_t *)actionList->list.array[actionIdx];
2786 switch(actionItem->id)
2788 case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
2790 /* If Action type is REPORT and
2791 * If RIC action definition's extraction and validation passes,
2793 * This action is added to action sequence list of subscription info */
2794 ricActionId = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID;
2796 if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType == RICactionType_report)
2798 ricSubscriptionInfo->actionSequence[ricActionId].actionId = ricActionId;
2799 ricSubscriptionInfo->actionSequence[ricActionId].type = REPORT;
2801 if(extractRicActionDef(ranFuncDb, &ricSubscriptionInfo->actionSequence[ricActionId].definition, \
2802 actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition, failureCause) == ROK)
2804 ricSubscriptionInfo->actionSequence[ricActionId].action = CONFIG_ADD;
2805 ricSubscriptionInfo->numOfActions++;
2810 /* In case of any failure, action is rejected
2811 * Added to rejected-action-list in subscription response */
2812 deleteActionSequence(&ricSubscriptionInfo->actionSequence[ricActionId]);
2814 subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].id = ricActionId;
2815 if(failureCause->causeType == E2_NOTHING)
2817 failureCause->causeType = E2_RIC_REQUEST;
2818 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
2820 memcpy(&subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].failureCause, \
2821 failureCause, sizeof(E2FailureCause));
2822 subsRsp->numOfRejectedActions++;
2826 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
2832 /* If there is even 1 action that can be added, return ROK */
2833 if(ricSubscriptionInfo->numOfActions)
2836 if(failureCause->causeType == E2_NOTHING)
2838 failureCause->causeType = E2_RIC_REQUEST;
2839 failureCause->cause = E2_ACTION_NOT_SUPPORTED;
2844 /******************************************************************
2846 * @brief Processes RIC Subscription Req sent by RIC
2850 * Function : procRicSubscriptionRequest
2852 * Functionality: Processes RIC Subscription Request from RIC
2854 * @params[in] E2AP_PDU_t ASN decoded E2AP message
2855 * @return ROK - success
2858 * ****************************************************************/
2859 uint8_t procRicSubscriptionRequest(E2AP_PDU_t *e2apMsg)
2861 uint8_t idx = 0, actionIdx = 0;
2863 uint16_t ranFuncId = 0;
2864 RicRequestId ricReqId;
2865 CmLList *ricSubscriptionNode = NULLP;
2866 RanFunction *ranFuncDb = NULLP;
2867 RICsubscriptionRequest_t *ricSubsReq = NULLP;
2868 RICsubscriptionDetails_t *subsDetails = NULLP;
2869 RicSubscription *ricSubscriptionInfo = NULLP;
2870 E2FailureCause failureCause;
2872 DU_LOG("\nINFO --> E2AP : RIC Subscription request received");
2874 memset(&failureCause, 0, sizeof(E2FailureCause));
2875 memset(&ricReqId, 0, sizeof(RicRequestId));
2877 ricSubsReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
2878 for(idx=0; idx<ricSubsReq->protocolIEs.list.count; idx++)
2880 if(ricSubsReq->protocolIEs.list.array[idx])
2882 switch(ricSubsReq->protocolIEs.list.array[idx]->id)
2884 case ProtocolIE_IDE2_id_RICrequestID:
2886 ricReqId.requestorId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID;
2887 ricReqId.instanceId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID;
2892 case ProtocolIE_IDE2_id_RANfunctionID:
2894 ranFuncId = ricSubsReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID;
2896 /* Validating RAN Function id */
2897 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
2901 failureCause.causeType = E2_RIC_REQUEST;
2902 failureCause.cause = E2_RAN_FUNCTION_ID_INVALID;
2907 if(ranFuncDb->numPendingSubsRsp >= MAX_PENDING_SUBSCRIPTION_RSP)
2909 failureCause.causeType = E2_RIC_REQUEST;
2910 failureCause.cause = E2_FUNCTION_RESOURCE_LIMIT;
2915 DU_ALLOC(ricSubscriptionInfo, sizeof(RicSubscription));
2916 if(!ricSubscriptionInfo)
2918 DU_LOG("\nERROR --> E2AP : Memory allocation failed for ricSubscriptionInfo");
2919 failureCause.causeType = E2_MISCELLANEOUS;
2920 failureCause.cause = E2_MISCELLANEOUS_CAUSE_UNSPECIFIED;
2924 ricSubscriptionInfo->requestId.requestorId = ricReqId.requestorId;
2925 ricSubscriptionInfo->requestId.instanceId = ricReqId.instanceId;
2926 ricSubscriptionInfo->ranFuncId = ranFuncId;
2928 for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
2930 ricSubscriptionInfo->actionSequence[actionIdx].actionId = -1;
2933 memset(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp], 0, sizeof(PendingSubsRspInfo));
2934 memcpy(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp].requestId,
2935 &ricReqId, sizeof(RicRequestId));
2936 ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp].ranFuncId = ranFuncId;
2940 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
2942 subsDetails = &ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails;
2944 /* Decode, Validate and record Event Trigger Definition */
2945 if(extractEventTriggerDef(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricEventTriggerDefinition, \
2946 &failureCause) != ROK)
2952 /* Decode, Validate and record RIC actions */
2953 if(extractRicActionToBeSetup(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricAction_ToBeSetup_List, \
2954 &failureCause, &ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp]) != ROK)
2963 DU_LOG("\nERROR --> E2AP : Invalid IE received in RIC SubsReq:%ld",
2964 ricSubsReq->protocolIEs.list.array[idx]->id);
2973 freeAperDecodingOfRicSubsReq(ricSubsReq);
2977 cmInitTimers(&(ricSubscriptionInfo->ricSubsReportTimer), 1);
2978 ricSubscriptionInfo->action = CONFIG_ADD;
2980 /* Add RAN subcription detail to RAN function */
2981 DU_ALLOC(ricSubscriptionNode, sizeof(CmLList));
2982 if(ricSubscriptionNode)
2984 ricSubscriptionNode->node = (PTR) ricSubscriptionInfo;
2985 cmLListAdd2Tail(&ranFuncDb->subscriptionList, ricSubscriptionNode);
2988 ranFuncDb->numPendingSubsRsp++;
2990 #ifdef KPI_CALCULATION
2991 /* Send statistics request to other DU entities */
2992 BuildAndSendStatsReq(ricSubscriptionInfo);
2997 DU_FREE(ricSubscriptionInfo, sizeof(RicSubscription));
3001 memset(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp], 0, sizeof(PendingSubsRspInfo));
3004 /* Send RIC Subcription Failure */
3005 BuildAndSendRicSubscriptionFailure(ricReqId, ranFuncId, failureCause);
3011 /******************************************************************
3013 * @brief Free RIC Subscription Failure
3017 * Function : FreeRicSubscriptionFailure
3019 * Functionality: Free RIC Subscription Failure
3021 * @params[in] E2AP PDU
3024 * ****************************************************************/
3025 void FreeRicSubscriptionFailure(E2AP_PDU_t *e2apMsg)
3027 uint8_t elemIdx = 0;
3028 RICsubscriptionFailure_t *ricSubscriptionFailure = NULLP;
3032 if(e2apMsg->choice.unsuccessfulOutcome)
3034 ricSubscriptionFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
3035 if(ricSubscriptionFailure->protocolIEs.list.array)
3037 for(elemIdx = 0; elemIdx < ricSubscriptionFailure->protocolIEs.list.count; elemIdx++)
3039 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array[elemIdx], sizeof(RICsubscriptionFailure_IEs_t));
3041 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array, ricSubscriptionFailure->protocolIEs.list.size);
3043 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
3045 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3049 /******************************************************************
3051 * @brief Fill and Send RIC Subscription Failure to RIC
3055 * Function : BuildAndSendRicSubscriptionFailure
3057 * Functionality: Fill and Send RIC Subscription Failure to RIC
3059 * @params[in] RIC Request ID
3062 * @return ROK - success
3065 * ****************************************************************/
3066 uint8_t BuildAndSendRicSubscriptionFailure(RicRequestId ricReqId, uint16_t ranFuncId, E2FailureCause failureCause)
3068 uint8_t ret = RFAILED;
3069 uint8_t elementCnt = 0, elemIdx = 0;
3070 E2AP_PDU_t *e2apMsg = NULLP;
3071 asn_enc_rval_t encRetVal; /* Encoder return value */
3072 RICsubscriptionFailure_t *ricSubscriptionFailure = NULLP;
3073 RICsubscriptionFailure_IEs_t *ricSubsFailIe = NULLP;
3077 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Failure\n");
3079 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
3080 if(e2apMsg == NULLP)
3082 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3086 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
3087 DU_ALLOC(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
3088 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
3090 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3093 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
3094 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
3095 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICsubscriptionFailure;
3097 ricSubscriptionFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
3100 ricSubscriptionFailure->protocolIEs.list.count = elementCnt;
3101 ricSubscriptionFailure->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionFailure_IEs_t *);
3102 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array, ricSubscriptionFailure->protocolIEs.list.size);
3103 if(!ricSubscriptionFailure->protocolIEs.list.array)
3105 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d]", __func__, __LINE__);
3109 for(elemIdx = 0; elemIdx < elementCnt; elemIdx++)
3111 DU_ALLOC(ricSubscriptionFailure->protocolIEs.list.array[elemIdx], sizeof(RICsubscriptionFailure_IEs_t));
3112 if(!ricSubscriptionFailure->protocolIEs.list.array[elemIdx])
3114 DU_LOG("\nERROR --> E2AP : Memory allocation at [%s] : Line [%d] for IE at index [%d]", \
3115 __func__, __LINE__, elemIdx);
3119 if(elemIdx < elementCnt)
3124 /* RIC Request ID */
3125 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3126 ricSubsFailIe->id = ProtocolIE_IDE2_id_RICrequestID;
3127 ricSubsFailIe->criticality = CriticalityE2_reject;
3128 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_RICrequestID;
3129 ricSubsFailIe->value.choice.RICrequestID.ricRequestorID = ricReqId.requestorId;
3130 ricSubsFailIe->value.choice.RICrequestID.ricInstanceID = ricReqId.instanceId;
3132 /* RAN Function ID */
3133 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3134 ricSubsFailIe->id = ProtocolIE_IDE2_id_RANfunctionID;
3135 ricSubsFailIe->criticality = CriticalityE2_reject;
3136 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_RANfunctionID;
3137 ricSubsFailIe->value.choice.RANfunctionID = ranFuncId;
3140 ricSubsFailIe = ricSubscriptionFailure->protocolIEs.list.array[elemIdx++];
3141 ricSubsFailIe->id = ProtocolIE_IDE2_id_CauseE2;
3142 ricSubsFailIe->criticality = CriticalityE2_reject;
3143 ricSubsFailIe->value.present = RICsubscriptionFailure_IEs__value_PR_CauseE2;
3144 fillE2Cause(&ricSubsFailIe->value.choice.CauseE2, failureCause);
3146 /* Prints the Msg formed */
3147 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
3148 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3150 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
3151 if(encRetVal.encoded == ENCODE_FAIL)
3153 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Failure Message (at %s)\n",\
3154 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3159 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Failure Message \n");
3160 #ifdef DEBUG_ASN_PRINT
3161 for(int i=0; i< encBufSize; i++)
3163 printf("%x",encBuf[i]);
3168 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
3170 DU_LOG("\nINFO --> E2AP : Sending RIC Subscription Failure");
3176 FreeRicSubscriptionFailure(e2apMsg);
3180 /*******************************************************************
3182 * @brief Free the RicIndication Message
3186 * Function : FreeRicIndication
3188 * Functionality: Free the RicIndication Message
3193 ******************************************************************/
3194 void FreeRicIndication(E2AP_PDU_t *e2apMsg)
3197 RICindication_t *ricIndicationMsg= NULLP;
3199 if(e2apMsg != NULLP)
3201 if(e2apMsg->choice.initiatingMessage != NULLP)
3203 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
3204 if(ricIndicationMsg!= NULLP)
3206 if(ricIndicationMsg->protocolIEs.list.array != NULLP)
3208 for(idx=0; idx<ricIndicationMsg->protocolIEs.list.count; idx++)
3210 if(ricIndicationMsg->protocolIEs.list.array[idx] != NULLP)
3212 switch(ricIndicationMsg->protocolIEs.list.array[idx]->id)
3214 case ProtocolIE_IDE2_id_RICrequestID:
3215 case ProtocolIE_IDE2_id_RANfunctionID:
3216 case ProtocolIE_IDE2_id_RICactionID:
3217 case ProtocolIE_IDE2_id_RICindicationType:
3220 case ProtocolIE_IDE2_id_RICindicationHeader:
3222 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf,\
3223 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
3226 case ProtocolIE_IDE2_id_RICindicationMessage:
3228 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf,\
3229 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
3235 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx],sizeof(RICindication_IEs_t));
3238 DU_FREE(ricIndicationMsg->protocolIEs.list.array,ricIndicationMsg->protocolIEs.list.size);
3241 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
3243 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
3247 /*******************************************************************
3249 * @brief Free measurement record
3253 * Function : freeMeasRecord
3255 * Functionality: Free all measurement recorded for a measurement
3256 * within an action in a RIC subscription
3258 * @param Measurement data to be freed
3261 ******************************************************************/
3262 void freeMeasData(MeasurementData_t *measData)
3264 uint8_t measIdx = 0, measRecIdx = 0;
3265 MeasurementRecord_t *measRecord = NULLP;
3267 if(measData->list.array)
3269 for(measIdx = 0; measIdx < measData->list.count; measIdx++)
3271 if(measData->list.array[measIdx])
3273 measRecord = &measData->list.array[measIdx]->measRecord;
3274 if(measRecord->list.array)
3276 for(measRecIdx = 0; measRecIdx < measRecord->list.count; measRecIdx++)
3278 DU_FREE(measRecord->list.array[measRecIdx], sizeof(MeasurementRecordItem_t));
3280 DU_FREE(measRecord->list.array, measRecord->list.size);
3282 DU_FREE(measData->list.array[measIdx], sizeof(MeasurementDataItem_t));
3285 DU_FREE(measData->list.array, measData->list.size);
3289 /*******************************************************************
3291 * @brief Fill measurement info list
3295 * Function : freeMeasInfoList
3297 * Functionality: Fills all measurement info within an action
3298 * in a RIC subscription
3300 * @param Measurement Info list to be freed
3303 ******************************************************************/
3304 void freeMeasInfoList(MeasurementInfoList_t *measInfoList)
3306 uint8_t measInfoIdx = 0;
3308 if(measInfoList->list.array)
3310 for(measInfoIdx = 0; measInfoIdx < measInfoList->list.count; measInfoIdx++)
3312 if(measInfoList->list.array[measInfoIdx])
3314 DU_FREE(measInfoList->list.array[measInfoIdx]->measType.choice.measName.buf, \
3315 measInfoList->list.array[measInfoIdx]->measType.choice.measName.size);
3317 DU_FREE(measInfoList->list.array[measInfoIdx], measInfoList->list.size);
3320 DU_FREE(measInfoList->list.array, measInfoList->list.size);
3324 /*******************************************************************
3326 * @brief Free E2SM-KPM Indication Message
3330 * Function : FreeE2smKpmIndicationMessage
3332 * Functionality: Free E2SM-KPM Indication Message
3334 * @param E2SM-KPM Indication message to be freed
3337 ******************************************************************/
3338 void FreeE2smKpmIndicationMessage(E2SM_KPM_IndicationMessage_t *e2smKpmIndMsg)
3340 E2SM_KPM_IndicationMessage_Format1_t *format1Msg = NULLP;
3342 switch(e2smKpmIndMsg->indicationMessage_formats.present)
3344 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format1:
3346 if(e2smKpmIndMsg->indicationMessage_formats.choice.indicationMessage_Format1)
3348 format1Msg = e2smKpmIndMsg->indicationMessage_formats.choice.indicationMessage_Format1;
3350 /* Measurement Data */
3351 freeMeasData(&format1Msg->measData);
3353 /* Measurement Info List */
3354 if(format1Msg->measInfoList)
3356 freeMeasInfoList(format1Msg->measInfoList);
3357 DU_FREE(format1Msg->measInfoList, sizeof(MeasurementInfoList_t));
3360 /* Granularity Period */
3361 DU_FREE(format1Msg->granulPeriod, sizeof(GranularityPeriod_t));
3363 DU_FREE(format1Msg, sizeof(E2SM_KPM_IndicationMessage_Format1_t));
3368 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_NOTHING:
3369 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format2:
3375 /*******************************************************************
3377 * @brief Fill measurement record
3381 * Function : fillMeasRecord
3383 * Functionality: Fills all measurement value for a measurement
3384 * within an action in a RIC subscription
3386 * @param Measurement record to be filled
3387 * Measurement database with measurement records
3388 * @return ROK - success
3391 ******************************************************************/
3392 uint8_t fillMeasRecord(MeasurementRecord_t *measRecord, MeasurementInfo *measInfoDb)
3394 uint8_t measRecIdx = 0;
3395 CmLList *measValNode = NULLP;
3398 measRecord->list.count = measInfoDb->measuredValue.count;
3399 measRecord->list.size = measRecord->list.count * sizeof(MeasurementRecordItem_t *);
3401 DU_ALLOC(measRecord->list.array, measRecord->list.size);
3402 if(!measRecord->list.array)
3404 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3408 for(measRecIdx = 0; measRecIdx < measRecord->list.count; measRecIdx++)
3410 DU_ALLOC(measRecord->list.array[measRecIdx], sizeof(MeasurementRecordItem_t));
3411 if(!measRecord->list.array[measRecIdx])
3413 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3419 CM_LLIST_FIRST_NODE(&measInfoDb->measuredValue, measValNode);
3422 measVal = *(double *)measValNode->node;
3423 if(measVal == (int)measVal)
3425 measRecord->list.array[measRecIdx]->present = MeasurementRecordItem_PR_integer;
3426 measRecord->list.array[measRecIdx]->choice.integer = (int)measVal;
3430 measRecord->list.array[measRecIdx]->present = MeasurementRecordItem_PR_real;
3431 measRecord->list.array[measRecIdx]->choice.real = measVal;
3434 measValNode= measValNode->next;
3435 /* Once the measurement record is added to the message, delete it from DB */
3438 deleteMeasuredValueList(&measInfoDb->measuredValue);
3442 /*******************************************************************
3444 * @brief Fills measuerement data
3448 * Function : fillMeasData
3450 * Functionality: Fill all measurement recorded for all measurements
3451 * in an action in a RIC subscription
3453 * @param Measurement data to be filled
3454 * Measurement info list from an action DB
3455 * @return ROK - success
3458 ******************************************************************/
3459 uint8_t fillMeasData(MeasurementData_t *measData, CmLListCp *measInfoListDb)
3461 uint8_t measIdx = 0;
3462 CmLList *measInfoNode = NULLP;
3463 MeasurementInfo *measInfoDb = NULLP;
3464 MeasurementRecord_t *measRecord = NULLP;
3466 measData->list.count = measInfoListDb->count;
3467 measData->list.size = measData->list.count * sizeof(MeasurementDataItem_t *);
3469 DU_ALLOC(measData->list.array, measData->list.size);
3470 if(!measData->list.array)
3472 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3477 CM_LLIST_FIRST_NODE(measInfoListDb, measInfoNode);
3480 measInfoDb = (MeasurementInfo *)measInfoNode->node;
3483 DU_ALLOC(measData->list.array[measIdx], sizeof(MeasurementDataItem_t));
3484 if(!measData->list.array[measIdx])
3486 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3490 measRecord = &measData->list.array[measIdx]->measRecord;
3491 if(fillMeasRecord(measRecord, measInfoDb) != ROK)
3493 DU_LOG("\nERROR --> E2AP : Failed to fill measurement record");
3498 measInfoNode = measInfoNode->next;
3504 /*******************************************************************
3506 * @brief Fill all measurement info
3510 * Function : fillMeasInfoList
3512 * Functionality: Fills all measurement info belonging to an action
3513 * in a RIC subscription
3515 * @param Measurement Info list to be filled
3516 * Measurement Info list from E2AP DB
3517 * @return ROK - success
3520 ******************************************************************/
3521 uint8_t fillMeasInfoList(MeasurementInfoList_t *measInfoList, CmLListCp *measInfoListDb)
3523 uint8_t measInfoIdx = 0;
3524 CmLList *measInfoNode = NULLP;
3525 MeasurementInfo *measInfoDb = NULLP;
3526 MeasurementInfoItem_t *measInfoItem = NULLP;
3528 measInfoList->list.count = measInfoListDb->count;
3529 measInfoList->list.size = measInfoList->list.count * sizeof(MeasurementInfoItem_t *);
3531 DU_ALLOC(measInfoList->list.array, measInfoList->list.size);
3532 if(!measInfoList->list.array)
3534 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3539 CM_LLIST_FIRST_NODE(measInfoListDb, measInfoNode);
3542 DU_ALLOC(measInfoList->list.array[measInfoIdx], sizeof(MeasurementInfoItem_t));
3543 if(!measInfoList->list.array[measInfoIdx])
3545 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3549 measInfoItem = measInfoList->list.array[measInfoIdx];
3550 measInfoDb = (MeasurementInfo *)measInfoNode->node;
3553 /* Measurement Type */
3554 measInfoItem->measType.present = MeasurementType_PR_measName;
3555 measInfoItem->measType.choice.measName.size = strlen(measInfoDb->measurementTypeName);
3557 DU_ALLOC(measInfoItem->measType.choice.measName.buf, measInfoItem->measType.choice.measName.size);
3558 if(!measInfoItem->measType.choice.measName.buf)
3560 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3564 memcpy(measInfoItem->measType.choice.measName.buf, measInfoDb->measurementTypeName,\
3565 measInfoItem->measType.choice.measName.size);
3569 measInfoNode = measInfoNode->next;
3576 /*******************************************************************
3578 * @brief Fill E2SM-KPM Indication Message Format 1
3582 * Function : fillE2smKpmIndMsgFormat1
3584 * Functionality: Fill E2SM-KPM Indication Message Format 1
3586 * @param Format 1 Message to be filled
3587 * Action Definition format 1 from E2AP DB
3588 * @return ROK - success
3591 ******************************************************************/
3592 uint8_t fillE2smKpmIndMsgFormat1(E2SM_KPM_IndicationMessage_Format1_t *format1Msg, ActionDefFormat1 *format1)
3594 /* Measurement Data */
3595 if(fillMeasData(&format1Msg->measData, &format1->measurementInfoList) != ROK)
3597 DU_LOG("\nERROR --> E2AP : Failed to fill measurement data");
3601 /* Measurement Information */
3602 DU_ALLOC(format1Msg->measInfoList, sizeof(MeasurementInfoList_t));
3603 if(!format1Msg->measInfoList)
3605 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3609 if(fillMeasInfoList(format1Msg->measInfoList, &format1->measurementInfoList) != ROK)
3611 DU_LOG("\nERROR --> E2AP : Failed to fill measurement information list");
3615 /* Granularity Period */
3616 DU_ALLOC(format1Msg->granulPeriod, sizeof(GranularityPeriod_t));
3617 if(!format1Msg->granulPeriod)
3619 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3622 *(format1Msg->granulPeriod) = format1->granularityPeriod;
3627 /*******************************************************************
3629 * @brief Fill RIC Indication Message buffer
3633 * Function : fillRicIndMsgBuf
3635 * Functionality: Fill E2SM-KPM Indication Message
3636 * Encode this message and copy to RIC Indication Message buffer
3638 * @param RIC Indication Message buffer to be filled
3639 * Source action info from E2AP DB
3640 * @return ROK - success
3643 ******************************************************************/
3644 uint8_t fillRicIndMsgBuf(RICindicationMessage_t *ricIndMsgBuf, ActionInfo *actionInfo)
3646 uint8_t ret = RFAILED;
3647 bool failedInFormat = false;
3648 E2SM_KPM_IndicationMessage_t e2smKpmIndMsg;
3649 asn_enc_rval_t encRetVal; /* Encoder return value */
3651 memset(&e2smKpmIndMsg, 0, sizeof(E2SM_KPM_IndicationMessage_t));
3655 /* E2SM-KPM Indication message format type */
3656 e2smKpmIndMsg.indicationMessage_formats.present = actionInfo->definition.formatType;
3657 switch(e2smKpmIndMsg.indicationMessage_formats.present)
3659 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format1:
3661 /* E2SM-KPM Indication message format 1 */
3662 DU_ALLOC(e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1, \
3663 sizeof(E2SM_KPM_IndicationMessage_Format1_t));
3664 if(!e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1)
3666 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3667 failedInFormat = true;
3671 if(fillE2smKpmIndMsgFormat1(e2smKpmIndMsg.indicationMessage_formats.choice.indicationMessage_Format1, \
3672 &actionInfo->definition.choice.format1) != ROK)
3674 DU_LOG("\nERROR --> E2AP : Failed to fill E2SM-KPM Indication message format 1");
3675 failedInFormat = true;
3681 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_NOTHING:
3682 case E2SM_KPM_IndicationMessage__indicationMessage_formats_PR_indicationMessage_Format2:
3685 DU_LOG("\nERROR --> E2AP : fillRicIndMsgBuf: Only Format 1 supported");
3686 failedInFormat = true;
3694 /* Encode E2SM-KPM Indication Message */
3695 xer_fprint(stdout, &asn_DEF_E2SM_KPM_IndicationMessage, &e2smKpmIndMsg);
3696 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3698 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_IndicationMessage, 0, &e2smKpmIndMsg, PrepFinalEncBuf, encBuf);
3699 if(encRetVal.encoded == ENCODE_FAIL)
3701 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM Indication Message (at %s)\n",\
3702 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3707 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SM-KPM Indication Message \n");
3708 #ifdef DEBUG_ASN_PRINT
3709 for(int i=0; i< encBufSize; i++)
3711 printf("%x",encBuf[i]);
3716 /* Copy encoded string to RIC Indication Message buffer */
3717 ricIndMsgBuf->size = encBufSize;
3718 DU_ALLOC(ricIndMsgBuf->buf, ricIndMsgBuf->size);
3719 if(!ricIndMsgBuf->buf)
3721 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3724 memset(ricIndMsgBuf->buf, 0, ricIndMsgBuf->size);
3725 memcpy(ricIndMsgBuf->buf, encBuf, encBufSize);
3731 /* Free E2SM-KPM Indication Message */
3732 FreeE2smKpmIndicationMessage(&e2smKpmIndMsg);
3737 /*******************************************************************
3739 * @brief Free E2SM-KPM Indication Header
3743 * Function : FreeE2smKpmIndicationHeader
3745 * Functionality: Free E2SM-KPM Indication Header
3747 * @param E2SM-KPM Indication Header to be free
3750 ******************************************************************/
3751 void FreeE2smKpmIndicationHeader(E2SM_KPM_IndicationHeader_t *e2smKpmIndHdr)
3753 E2SM_KPM_IndicationHeader_Format1_t *format1 = NULLP;
3757 switch(e2smKpmIndHdr->indicationHeader_formats.present)
3759 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_indicationHeader_Format1:
3761 if(e2smKpmIndHdr->indicationHeader_formats.choice.indicationHeader_Format1)
3763 format1 = e2smKpmIndHdr->indicationHeader_formats.choice.indicationHeader_Format1;
3765 DU_FREE(format1->colletStartTime.buf, format1->colletStartTime.size);
3766 DU_FREE(format1, sizeof(E2SM_KPM_IndicationHeader_Format1_t));
3770 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_NOTHING:
3777 /*******************************************************************
3779 * @brief Fill RIC Indication Header buffer
3783 * Function : fillRicIndHeader
3785 * Functionality: Fill E2SM-KPM Indication Header
3786 * Encode this message and copy to RIC Indication Header buffer
3788 * @param RIC Indication Header buffer to be filled
3789 * Source RIC subscription info from E2AP DB
3790 * @return ROK - success
3793 ******************************************************************/
3794 uint8_t fillRicIndHeader(RICindicationHeader_t *ricIndHdr, RicSubscription *ricSubsInfo)
3796 uint8_t ret = RFAILED;
3797 uint8_t secBufIdx = 0, milliSecBufIdx = 0;
3799 bool formatFailure = false;
3800 RanFunction *ranFunc = NULLP;
3801 ReportStartTime *startTime = NULLP;
3802 E2SM_KPM_IndicationHeader_t e2smKpmIndHdr;
3803 E2SM_KPM_IndicationHeader_Format1_t *format1 = NULLP;
3804 asn_enc_rval_t encRetVal; /* Encoder return value */
3808 ranFunc = fetchRanFuncFromRanFuncId(ricSubsInfo->ranFuncId);
3809 if(ranFunc == NULLP)
3811 DU_LOG("\nERROR --> E2AP : RAN Function ID [%d] not found", ricSubsInfo->ranFuncId);
3815 memset(&e2smKpmIndHdr, 0, sizeof(E2SM_KPM_IndicationHeader_t));
3817 e2smKpmIndHdr.indicationHeader_formats.present = ranFunc->ricIndicationHeaderFormat;
3818 switch(e2smKpmIndHdr.indicationHeader_formats.present)
3820 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_indicationHeader_Format1:
3822 DU_ALLOC(e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1, \
3823 sizeof(E2SM_KPM_IndicationHeader_Format1_t));
3824 if(!e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1)
3826 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3827 formatFailure = true;
3830 format1 = e2smKpmIndHdr.indicationHeader_formats.choice.indicationHeader_Format1;
3832 /* Fetch reporting period start time from DB */
3833 switch(ricSubsInfo->eventTriggerDefinition.formatType)
3837 startTime = &ricSubsInfo->eventTriggerDefinition.choice.format1.startTime;
3841 format1->colletStartTime.size = 8 * sizeof(uint8_t);
3842 DU_ALLOC(format1->colletStartTime.buf, format1->colletStartTime.size);
3843 if(!format1->colletStartTime.buf)
3845 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3846 formatFailure = true;
3850 /* As per O-RAN.WG3.E2SM-KPM-R003-v03.00, section 8.3.12 and
3851 * RFC 5905, section 6 :
3852 * Time stamp has a 64-bit format where first 32-bit is seconds
3853 * and next 32-bit is fraction in picosecond-level.
3854 * This fraction has been rounded in microseconds.
3857 * Storing 32-bit seconds at MSB 0-3 and
3858 * 32-bit milliseconds at next 4 bytes i.e. bytes 4-7
3862 for(byteIdx = 3; byteIdx >= 0; byteIdx--)
3864 format1->colletStartTime.buf[secBufIdx++] = startTime->timeInSec >> (8*byteIdx);
3865 format1->colletStartTime.buf[milliSecBufIdx++] = startTime->timeInMilliSec >> (8*byteIdx);
3870 case E2SM_KPM_IndicationHeader__indicationHeader_formats_PR_NOTHING:
3873 DU_LOG("\nERROR --> E2AP : Only E2SM-KPM Indication Header Format 1 supported");
3874 formatFailure = true;
3882 /* Encode E2SM-KPM Indication Header */
3883 xer_fprint(stdout, &asn_DEF_E2SM_KPM_IndicationHeader, &e2smKpmIndHdr);
3884 memset(encBuf, 0, ENC_BUF_MAX_LEN);
3886 encRetVal = aper_encode(&asn_DEF_E2SM_KPM_IndicationHeader, 0, &e2smKpmIndHdr, PrepFinalEncBuf, encBuf);
3887 if(encRetVal.encoded == ENCODE_FAIL)
3889 DU_LOG("\nERROR --> E2AP : Could not encode E2SM-KPM Indication Header (at %s)\n",\
3890 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3895 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SM-KPM Indication Header \n");
3896 #ifdef DEBUG_ASN_PRINT
3897 for(int i=0; i< encBufSize; i++)
3899 printf("%x",encBuf[i]);
3904 /* Copy encoded string to RIC Indication Header buffer */
3905 ricIndHdr->size = encBufSize;
3906 DU_ALLOC(ricIndHdr->buf, ricIndHdr->size);
3909 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3912 memset(ricIndHdr->buf, 0, ricIndHdr->size);
3913 memcpy(ricIndHdr->buf, encBuf, encBufSize);
3918 /* Free E2SM-KPM Indication Header */
3919 FreeE2smKpmIndicationHeader(&e2smKpmIndHdr);
3924 /*******************************************************************
3926 * brief Fill the RIC Indication Message
3930 * Function : fillRicIndication
3932 * Functionality: Fills the RIC Indication Message
3934 * @param RIC Indication Message to be filled
3935 * RIC Subscription DB
3937 * @return ROK - success
3940 ******************************************************************/
3941 uint8_t fillRicIndication(RICindication_t *ricIndicationMsg, RicSubscription *ricSubscriptionInfo, ActionInfo *actionInfo)
3943 uint8_t elementCnt = 0, idx = 0;
3948 ricIndicationMsg->protocolIEs.list.count = elementCnt;
3949 ricIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(RICindication_IEs_t *);
3951 /* Initialize the Ric Indication members */
3952 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array, ricIndicationMsg->protocolIEs.list.size);
3953 if(ricIndicationMsg->protocolIEs.list.array == NULLP)
3955 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3959 for(idx=0; idx<elementCnt; idx++)
3961 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx], sizeof(RICindication_IEs_t));
3962 if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP)
3964 DU_LOG("\nERROR --> E2AP : Memory allocation in [%s] at line [%d]", __func__, __LINE__);
3969 /* RIC Request ID */
3971 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
3972 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
3973 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICrequestID;
3974 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID = \
3975 ricSubscriptionInfo->requestId.requestorId;
3976 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID = \
3977 ricSubscriptionInfo->requestId.instanceId;
3979 /* RAN Function ID */
3981 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
3982 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
3983 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RANfunctionID;
3984 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RANfunctionID = ricSubscriptionInfo->ranFuncId;
3988 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionID;
3989 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
3990 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICactionID;
3991 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICactionID = actionInfo->actionId;
3993 /* RIC Indication Type */
3995 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationType;
3996 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
3997 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationType;
3998 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationType = actionInfo->type;
4000 /* RIC Indication Header */
4002 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationHeader;
4003 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4004 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationHeader;
4005 if(fillRicIndHeader(&ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader, \
4006 ricSubscriptionInfo) != ROK)
4008 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication header");
4012 /* RIC Indication Message */
4014 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationMessage;
4015 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
4016 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = RICindication_IEs__value_PR_RICindicationMessage;
4017 if(fillRicIndMsgBuf(&ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage, \
4020 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication Message");
4027 /*******************************************************************
4029 * @brief Builds and Send the RicIndication Message
4033 * Function : BuildAndSendRicIndication
4035 * Functionality:Fills the RicIndication Message
4037 * @return ROK - success
4040 ******************************************************************/
4042 uint8_t BuildAndSendRicIndication(RicSubscription *ricSubscriptionInfo, ActionInfo *actionInfo)
4044 uint8_t ret = RFAILED;
4045 E2AP_PDU_t *e2apMsg = NULLP;
4046 RICindication_t *ricIndicationMsg = NULLP;
4047 asn_enc_rval_t encRetVal; /* Encoder return value */
4051 DU_LOG("\nINFO --> E2AP : Building RIC Indication Message\n");
4053 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4054 if(e2apMsg == NULLP)
4056 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4060 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4061 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4062 if(e2apMsg->choice.initiatingMessage == NULLP)
4064 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4067 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication;
4068 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4069 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICindication;
4071 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
4073 if(fillRicIndication(ricIndicationMsg, ricSubscriptionInfo, actionInfo) != ROK)
4075 DU_LOG("\nERROR --> E2AP : Failed to fill RIC Indication message");
4079 /* Prints the Msg formed */
4080 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4081 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4083 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
4085 if(encRetVal.encoded == ENCODE_FAIL)
4087 DU_LOG("\nERROR --> E2AP : Could not encode RIC Indication Message (at %s)\n",\
4088 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4093 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Indication Message \n");
4094 #ifdef DEBUG_ASN_PRINT
4095 for(int i=0; i< encBufSize; i++)
4097 printf("%x",encBuf[i]);
4102 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
4104 DU_LOG("\nINFO --> E2AP : Sending RIC Indication Message");
4110 FreeRicIndication(e2apMsg);
4114 /*******************************************************************
4116 * @brief free e2 node component configuration req and rsp
4120 * Function : freeE2NodeComponentConfiguration
4123 * - free e2 node component configuration req and rsp
4125 * @params[in] E2nodeComponentConfiguration_t *e2nodeComponentConfiguration
4126 * @return ROK - success
4129 * ****************************************************************/
4131 void freeE2NodeComponentConfiguration(E2nodeComponentConfiguration_t *e2nodeComponentConfiguration)
4133 /* Free E2 Node Component Request Part */
4134 DU_FREE(e2nodeComponentConfiguration->e2nodeComponentRequestPart.buf, e2nodeComponentConfiguration->e2nodeComponentRequestPart.size);
4136 /* Free E2 Node Component Response Part */
4137 DU_FREE(e2nodeComponentConfiguration->e2nodeComponentResponsePart.buf, e2nodeComponentConfiguration->e2nodeComponentResponsePart.size);
4141 /*******************************************************************
4143 * @brief free e2 node component component identifier
4147 * Function : freeE2NodeComponentIdentifier
4150 * - free e2 node component component identifier
4152 * @params[in] E2nodeComponentID_t *componentID
4153 * @return ROK - success
4156 * ****************************************************************/
4158 void freeE2NodeComponentIdentifier(E2nodeComponentID_t *componentID)
4160 if(componentID->choice.e2nodeComponentInterfaceTypeF1)
4162 DU_FREE(componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf, componentID->choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
4163 DU_FREE(componentID->choice.e2nodeComponentInterfaceTypeF1, sizeof(E2nodeComponentInterfaceF1_t));
4168 /*******************************************************************
4170 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
4174 * Function : FreeE2NodeConfigUpdate
4177 * - freeing the memory allocated for E2nodeConfigurationUpdate
4179 * @params[in] E2AP_PDU_t *e2apMsg
4180 * @return ROK - success
4183 * ****************************************************************/
4185 void FreeE2NodeConfigUpdate(E2AP_PDU_t *e2apMsg)
4187 uint8_t arrIdx =0, e2NodeUpdateListIdx=0, e2NodeRemovalListIdx=0, e2NodeAddListIdx=0;
4188 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate =NULL;
4189 E2nodeComponentConfigUpdate_List_t *e2NodeUpdateList =NULL;
4190 E2nodeComponentConfigUpdate_ItemIEs_t *e2NodeUpdateItem =NULL;
4191 E2nodeComponentConfigRemoval_List_t *e2NodeRemovalList =NULL;
4192 E2nodeComponentConfigRemoval_ItemIEs_t *e2NodeRemovalItem =NULL;
4193 E2nodeComponentConfigAddition_List_t *e2NodeAddList =NULL;
4194 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem =NULL;
4196 if(e2apMsg != NULLP)
4198 if(e2apMsg->choice.initiatingMessage != NULLP)
4200 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
4201 if(e2NodeConfigUpdate->protocolIEs.list.array != NULLP)
4203 for(arrIdx = 0; arrIdx < e2NodeConfigUpdate->protocolIEs.list.count; arrIdx++)
4205 if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx])
4208 switch(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id)
4210 case ProtocolIE_IDE2_id_TransactionID:
4213 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
4215 e2NodeAddList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
4216 if(e2NodeAddList->list.array)
4218 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
4220 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
4222 freeE2NodeComponentConfiguration(&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration);
4223 freeE2NodeComponentIdentifier(&e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID);
4224 DU_FREE(e2NodeAddItem, sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
4226 DU_FREE(e2NodeAddList->list.array, e2NodeAddList->list.size);
4230 case ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate:
4232 e2NodeUpdateList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdate_List;
4233 if(e2NodeUpdateList->list.array)
4235 for(e2NodeUpdateListIdx = 0; e2NodeUpdateListIdx< e2NodeUpdateList->list.count; e2NodeUpdateListIdx++)
4237 e2NodeUpdateItem = (E2nodeComponentConfigUpdate_ItemIEs_t *) e2NodeUpdateList->list.array[e2NodeUpdateListIdx];
4239 freeE2NodeComponentConfiguration(&e2NodeUpdateItem->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentConfiguration);
4240 freeE2NodeComponentIdentifier(&e2NodeUpdateItem->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentID);
4241 DU_FREE(e2NodeUpdateItem, sizeof(E2nodeComponentConfigUpdate_ItemIEs_t));
4243 DU_FREE(e2NodeUpdateList->list.array, e2NodeUpdateList->list.size);
4247 case ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval:
4249 e2NodeRemovalList = &e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemoval_List;
4250 if(e2NodeRemovalList->list.array)
4252 for(e2NodeRemovalListIdx = 0; e2NodeRemovalListIdx< e2NodeRemovalList->list.count; e2NodeRemovalListIdx++)
4254 e2NodeRemovalItem = (E2nodeComponentConfigRemoval_ItemIEs_t *) e2NodeRemovalList->list.array[e2NodeRemovalListIdx];
4256 freeE2NodeComponentIdentifier(&e2NodeRemovalItem->value.choice.E2nodeComponentConfigRemoval_Item.e2nodeComponentID);
4257 DU_FREE(e2NodeRemovalItem, sizeof(E2nodeComponentConfigRemoval_ItemIEs_t));
4259 DU_FREE(e2NodeRemovalList->list.array, e2NodeRemovalList->list.size);
4267 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
4270 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
4272 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4274 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4278 /*******************************************************************
4280 * @brief Buld and send the E2 node config update msg
4284 * Function : BuildAndSendE2NodeConfigUpdate
4287 * - Buld and send the E2 node config update msg
4290 * @return ROK - success
4293 * ****************************************************************/
4295 uint8_t BuildAndSendE2NodeConfigUpdate(E2NodeConfigList *e2NodeList)
4297 uint8_t ret = RFAILED;
4298 uint8_t arrIdx = 0,elementCnt = 0, transId=0;
4299 E2AP_PDU_t *e2apMsg = NULLP;
4300 asn_enc_rval_t encRetVal; /* Encoder return value */
4301 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate = NULLP;
4303 DU_LOG("\nINFO --> E2AP : Building E2 Node config update\n");
4306 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4307 if(e2apMsg == NULLP)
4309 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4313 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4314 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4315 if(e2apMsg->choice.initiatingMessage == NULLP)
4317 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
4320 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4321 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
4322 e2apMsg->choice.initiatingMessage->value.present = \
4323 InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate;
4324 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
4327 if(e2NodeList->addE2NodeCount)
4329 if(e2NodeList->updateE2NodeCount)
4331 if(e2NodeList->removeE2NodeCount)
4334 e2NodeConfigUpdate->protocolIEs.list.count = elementCnt;
4335 e2NodeConfigUpdate->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdate_IEs_t*);
4336 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
4337 if(e2NodeConfigUpdate->protocolIEs.list.array == NULLP)
4339 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
4343 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
4345 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
4346 if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx] == NULLP)
4349 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
4354 if(arrIdx<elementCnt)
4358 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
4359 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4360 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_TransactionID;
4361 transId = assignTransactionId();
4362 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
4364 if(e2NodeList->addE2NodeCount)
4367 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition;
4368 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4369 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigAddition_List;
4370 if(BuildE2NodeConfigAddList(&(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List),\
4371 ProcedureCodeE2_id_E2nodeConfigurationUpdate, e2NodeList->addE2NodeCount, e2NodeList->addE2Node)!=ROK)
4373 DU_LOG("\nERROR --> E2AP : Failed to create E2 Node config list");
4378 if(e2NodeList->updateE2NodeCount)
4381 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigUpdate;
4382 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4383 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigUpdate_List;
4384 if(BuildE2NodeConfigUpdateList(&e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigUpdate_List,\
4385 e2NodeList->updateE2NodeCount, e2NodeList->updateE2Node) != ROK)
4388 DU_LOG("\nERROR --> E2AP : Failed to update the E2 node configuration");
4393 if(e2NodeList->removeE2NodeCount)
4396 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigRemoval;
4397 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
4398 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigRemoval_List;
4399 if(BuildE2NodeConfigRemoveList(&e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigRemoval_List,\
4400 e2NodeList->removeE2NodeCount, e2NodeList->removeE2Node) != ROK)
4403 DU_LOG("\nERROR --> E2AP : Failed to remove the E2 node configuration");
4408 /* Prints the Msg formed */
4409 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4411 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4413 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
4414 if(encRetVal.encoded == ENCODE_FAIL)
4416 DU_LOG("\nERROR --> E2AP : Could not encode E2nodeConfigurationUpdate structure (at %s)\n",\
4417 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4422 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2nodeConfigurationUpdate\n");
4423 #ifdef DEBUG_ASN_PRINT
4424 for(int i=0; i< encBufSize; i++)
4426 printf("%x",encBuf[i]);
4430 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize))
4432 DU_LOG("\nERROR --> E2AP : Sending E2 node config update failed");
4436 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
4437 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
4438 memcpy(&duCb.e2apDb.e2TimersInfo.e2Timers.e2NodeConfigUpdate.configList, e2NodeList, sizeof(E2NodeConfigList));
4443 FreeE2NodeConfigUpdate(e2apMsg);
4447 /*******************************************************************
4449 * @brief Deallocate the memory allocated for E2ResetRequest msg
4453 * Function : FreeE2ResetRequest
4456 * - freeing the memory allocated for E2ResetRequest
4458 * @params[in] E2AP_PDU_t *e2apMsg
4459 * @return ROK - success
4462 * ****************************************************************/
4463 void FreeE2ResetRequest(E2AP_PDU_t *e2apMsg)
4466 ResetRequestE2_t *resetReq = NULLP;
4468 if(e2apMsg != NULLP)
4470 if(e2apMsg->choice.initiatingMessage != NULLP)
4472 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
4473 if(resetReq->protocolIEs.list.array)
4475 for(ieIdx = 0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
4477 DU_FREE(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
4479 DU_FREE(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
4481 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4483 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
4487 /*******************************************************************
4489 * @brief Build and send the E2 reset request msg
4493 * Function : BuildAndSendE2ResetRequest
4496 * - Buld and send the E2 reset request msg to RIC
4500 * @return ROK - success
4503 * ****************************************************************/
4504 uint8_t BuildAndSendE2ResetRequest(E2FailureCause resetCause)
4506 uint8_t ieIdx = 0, elementCnt = 0, transId = 0;
4507 uint8_t ret = RFAILED;
4508 E2AP_PDU_t *e2apMsg = NULLP;
4509 ResetRequestE2_t *resetReq = NULLP;
4510 asn_enc_rval_t encRetVal; /* Encoder return value */
4512 DU_LOG("\nINFO --> E2AP : Building E2 Reset Request\n");
4516 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
4517 if(e2apMsg == NULLP)
4519 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for E2AP-PDU failed");
4523 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
4524 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
4525 if(e2apMsg->choice.initiatingMessage == NULLP)
4527 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for initiatingMessage");
4531 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset;
4532 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
4533 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2;
4534 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
4537 resetReq->protocolIEs.list.count = elementCnt;
4538 resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *);
4540 DU_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
4541 if(!resetReq->protocolIEs.list.array)
4543 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
4544 Reset Request IE array");
4548 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
4550 DU_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
4551 if(!resetReq->protocolIEs.list.array[ieIdx])
4553 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
4554 Reset Request IE array element");
4559 /* In case of failure */
4560 if(ieIdx < elementCnt)
4564 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
4565 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
4566 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID;
4567 transId = assignTransactionId();
4568 resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
4571 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
4572 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
4573 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2;
4574 fillE2Cause(&resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2, resetCause);
4576 /* Prints the Msg formed */
4577 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
4579 memset(encBuf, 0, ENC_BUF_MAX_LEN);
4581 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
4583 if(encRetVal.encoded == ENCODE_FAIL)
4585 DU_LOG("\nERROR --> E2AP : Could not encode reset request structure (at %s)\n",\
4586 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
4591 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for reset request\n");
4592 #ifdef DEBUG_ASN_PRINT
4593 for(int i=0; i< encBufSize; i++)
4595 printf("%x",encBuf[i]);
4599 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
4601 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
4605 /* In case the message is sent successfully, store the transaction info to
4606 * be used when response is received */
4607 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
4608 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
4614 /* Free all memory */
4615 FreeE2ResetRequest(e2apMsg);
4619 /*******************************************************************
4621 * @brief Deallocate the memory allocated for Reset Response msg
4625 * Function : freeAperDecodingOfE2ResetRsp
4628 * - freeing the memory allocated for Reset response
4630 * @params[in] ResetResponseE2_t *resetResponse
4633 * ****************************************************************/
4634 void freeAperDecodingOfE2ResetRsp(ResetResponseE2_t *resetResponse)
4640 if(resetResponse->protocolIEs.list.array)
4642 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
4644 if(resetResponse->protocolIEs.list.array[ieIdx])
4646 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
4648 case ProtocolIE_IDE2_id_TransactionID:
4651 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
4654 free(resetResponse->protocolIEs.list.array[ieIdx]);
4657 free(resetResponse->protocolIEs.list.array);
4662 /******************************************************************
4664 * @brief Processes E2 Reset Response sent by RIC
4668 * Function : procResetResponse
4670 * Functionality: Processes E2 Reset Response sent by RIC
4672 * @params[in] E2AP_PDU_t ASN decoded E2AP message
4675 * ****************************************************************/
4676 void procResetResponse(E2AP_PDU_t *e2apMsg)
4678 bool invalidTransId=false;
4679 uint8_t ieIdx =0, transId =0;
4680 uint16_t ranFuncIdx=0;
4681 ResetResponseE2_t *resetResponse =NULLP;
4683 DU_LOG("\nINFO --> E2AP : E2 Reset Response received");
4684 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;;
4686 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
4688 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
4690 case ProtocolIE_IDE2_id_TransactionID:
4692 transId = resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
4693 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) && \
4694 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
4696 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
4700 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
4701 invalidTransId = true;
4705 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
4707 for(ranFuncIdx=0; ranFuncIdx<MAX_RAN_FUNCTION; ranFuncIdx++)
4709 if(duCb.e2apDb.ranFunction[ranFuncIdx].id >0)
4711 deleteRicSubscriptionList(&(duCb.e2apDb.ranFunction[ranFuncIdx].subscriptionList));
4712 memset(&(duCb.e2apDb.ranFunction[ranFuncIdx].pendingSubsRspInfo), 0, MAX_PENDING_SUBSCRIPTION_RSP*sizeof(PendingSubsRspInfo));
4719 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2 Reset Response : %ld",
4720 resetResponse->protocolIEs.list.array[ieIdx]->id);
4725 if(invalidTransId == true)
4731 freeAperDecodingOfE2ResetRsp(resetResponse);
4734 /******************************************************************
4736 * @brief Deallocation of memory allocated by aper decoder for e2 setup Failure
4740 * Function : freeAperDecodingOfE2SetupFailure
4742 * Functionality: Deallocation of memory allocated by aper decoder for e2
4745 * @params[in] E2setupFailure_t *e2SetupFailure;
4748 * ****************************************************************/
4749 void freeAperDecodingOfE2SetupFailure(E2setupFailure_t *e2SetupFailure)
4755 if(e2SetupFailure->protocolIEs.list.array)
4757 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
4759 if(e2SetupFailure->protocolIEs.list.array[arrIdx])
4761 free(e2SetupFailure->protocolIEs.list.array[arrIdx]);
4764 free(e2SetupFailure->protocolIEs.list.array);
4768 /******************************************************************
4770 * @brief Processes E2 Setup Failure sent by RIC
4774 * Function : procE2SetupFailure
4776 * Functionality: Processes E2 Setup failure sent by RIC
4778 * @params[in] E2AP_PDU_t ASN decoded E2AP message
4779 * @return ROK - success
4782 * ****************************************************************/
4783 void procE2SetupFailure(E2AP_PDU_t *e2apMsg)
4785 uint8_t arrIdx =0, transId =0, timerValue=0;
4786 E2setupFailure_t *e2SetupFailure;
4788 DU_LOG("\nINFO --> E2AP : E2 Setup failure received");
4789 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
4791 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
4793 switch(e2SetupFailure->protocolIEs.list.array[arrIdx]->id)
4795 case ProtocolIE_IDE2_id_TransactionID:
4797 transId = e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
4798 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
4799 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
4801 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
4805 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
4810 case ProtocolIE_IDE2_id_TimeToWaitE2:
4812 timerValue = convertE2WaitTimerEnumToValue(e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
4813 if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR)) == FALSE)
4815 duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR, timerValue);
4819 DU_LOG("\nERROR --> E2AP : EVENT_E2_SETUP_TMR timer is already running");
4827 freeAperDecodingOfE2SetupFailure(e2SetupFailure);
4829 /******************************************************************
4831 * @brief Deallocation of memory allocated by aper decoder for RIC service Query
4835 * Function : freeAperDecodingOfRicServiceQuery
4837 * Functionality: Deallocation of memory allocated by aper decoder for RIC
4840 * @params[in] RICserviceQuery_t *ricServiceQuery;
4843 * ****************************************************************/
4845 void freeAperDecodingOfRicServiceQuery(RICserviceQuery_t *ricServiceQuery)
4847 uint8_t arrIdx,ranFuncIdx;
4848 RANfunctionsID_List_t *ranFuncAddedList;
4852 if(ricServiceQuery->protocolIEs.list.array)
4854 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
4856 if(ricServiceQuery->protocolIEs.list.array[arrIdx])
4858 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
4860 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
4862 ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
4863 if(ranFuncAddedList->list.array)
4865 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
4867 free(ranFuncAddedList->list.array[ranFuncIdx]);
4869 free(ranFuncAddedList->list.array);;
4876 free(ricServiceQuery->protocolIEs.list.array[arrIdx]);
4879 free(ricServiceQuery->protocolIEs.list.array);
4883 /*******************************************************************
4885 * @brief Build RanFunction Delete List
4889 * Function : BuildRanFunctionDeleteList
4891 * Functionality: Build RanFunction Delete List
4894 * RANfunctionsID List
4895 * Count of the RAN function
4896 * Received RAN function list
4898 * @return ROK - success
4901 ******************************************************************/
4903 uint8_t BuildRanFunctionDeleteList(RANfunctionsID_List_t *deleteList, uint8_t count, RanFuncInfo *recvdRanFunc)
4905 uint8_t ranFuncIdx=0;
4906 RANfunctionID_ItemIEs_t *delRanFuncItem;
4910 deleteList->list.count = count;
4911 deleteList->list.size = deleteList->list.count * sizeof(RANfunctionID_ItemIEs_t*);
4912 DU_ALLOC(deleteList->list.array, deleteList->list.size);
4913 if(deleteList->list.array == NULLP)
4915 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
4918 for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++)
4920 DU_ALLOC(deleteList->list.array[ranFuncIdx], sizeof(RANfunctionID_ItemIEs_t));
4921 if(deleteList->list.array[ranFuncIdx] == NULLP)
4923 DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
4926 delRanFuncItem= (RANfunctionID_ItemIEs_t *) deleteList->list.array[ranFuncIdx];
4927 delRanFuncItem->id = ProtocolIE_IDE2_id_RANfunctionID_Item;
4928 delRanFuncItem->criticality = CriticalityE2_ignore;
4929 delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionID = recvdRanFunc[ranFuncIdx].id;
4930 delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionRevision = recvdRanFunc[ranFuncIdx].revisionCounter;
4936 /*******************************************************************
4938 * @brief De Allocate Ric Service Update message
4942 * Function : FreeRicServiceUpdate
4944 * Functionality: De-Allocating Ric Service Update message
4946 * @params[in] E2AP_PDU_t *e2apMsg
4950 * ****************************************************************/
4952 void FreeRicServiceUpdate(E2AP_PDU_t *e2apMsg)
4955 uint8_t ranFuncAddListIdx=0, ranFuncDelIdx=0;
4956 RICserviceUpdate_t *ricServiceUpdate;
4957 RANfunctions_List_t *ranFunctionsList;
4958 RANfunction_ItemIEs_t *ranFuncItemIe;
4959 RANfunction_Item_t *ranFunItem;
4960 RANfunctionsID_List_t *deleteList;
4962 /* De-allocating Memory */
4963 if(e2apMsg != NULLP)
4965 if(e2apMsg->choice.initiatingMessage != NULLP)
4967 ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate;
4968 if(ricServiceUpdate->protocolIEs.list.array != NULLP)
4970 for(arrIdx = 0; arrIdx < ricServiceUpdate->protocolIEs.list.count; arrIdx++)
4972 if(ricServiceUpdate->protocolIEs.list.array[arrIdx] != NULLP)
4974 switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id)
4976 case ProtocolIE_IDE2_id_TransactionID:
4979 case ProtocolIE_IDE2_id_RANfunctionsAdded:
4980 case ProtocolIE_IDE2_id_RANfunctionsModified:
4982 ranFunctionsList = &(ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List);
4983 if(ranFunctionsList->list.array)
4985 for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++)
4987 if(ranFunctionsList->list.array[ranFuncAddListIdx])
4989 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx];
4990 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
4991 DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size);
4992 DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size);
4993 DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t));
4996 DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size);
5000 case ProtocolIE_IDE2_id_RANfunctionsDeleted:
5002 deleteList= &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5003 if(deleteList->list.array)
5005 for(ranFuncDelIdx = 0; ranFuncDelIdx< deleteList->list.count; ranFuncDelIdx++)
5007 DU_FREE(deleteList->list.array[ranFuncDelIdx], sizeof(RANfunctionID_ItemIEs_t));
5009 DU_FREE(deleteList->list.array, deleteList->list.size);
5015 DU_LOG("\nERROR --> E2AP: Invalid event at ricServiceUpdate %ld ",\
5016 (ricServiceUpdate->protocolIEs.list.array[arrIdx]->id));
5019 DU_FREE(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t));
5022 DU_FREE(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
5024 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5026 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
5030 /*******************************************************************
5032 * @brief Builds and Send the RicServiceUpdateuest
5036 * Function : BuildAndSendRicServiceUpdate
5038 * Functionality:Fills the RicServiceUpdateuest
5040 * @return ROK - success
5043 ******************************************************************/
5045 uint8_t BuildAndSendRicServiceUpdate(RicServiceUpdate serviceUpdate)
5047 uint8_t arrIdx = 0, elementCnt=0;
5048 uint8_t transId = 0, ret = RFAILED;
5049 bool memAllocFailed =false;
5050 E2AP_PDU_t *e2apMsg = NULLP;
5051 RICserviceUpdate_t *ricServiceUpdate = NULLP;
5052 asn_enc_rval_t encRetVal; /* Encoder return value */
5054 DU_LOG("\nINFO --> E2AP : Building Ric Service Update\n");
5057 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5058 if(e2apMsg == NULLP)
5060 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
5063 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
5064 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5065 if(e2apMsg->choice.initiatingMessage == NULLP)
5067 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
5070 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
5071 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
5072 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceUpdate;
5073 ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate;
5075 /* For TransId IE, set elementCnt to 1.
5076 If there is any item in the RAN function add list, RAN function modification list, or RAN function delete list, increment the elementCnt.*/
5079 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
5081 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified)
5083 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted)
5086 ricServiceUpdate->protocolIEs.list.count = elementCnt;
5087 ricServiceUpdate->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdate_IEs_t*);
5089 /* Initialize the E2Setup members */
5090 DU_ALLOC(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
5091 if(ricServiceUpdate->protocolIEs.list.array == NULLP)
5093 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
5097 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
5099 DU_ALLOC(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t));
5100 if(ricServiceUpdate->protocolIEs.list.array[arrIdx] == NULLP)
5102 memAllocFailed = true;
5103 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayIdx [%d]", arrIdx);
5107 if(memAllocFailed == true)
5113 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
5114 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5115 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
5116 if(serviceUpdate.dir == E2_NODE_INITIATED)
5117 transId = assignTransactionId();
5119 transId = serviceUpdate.transId;
5120 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
5122 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
5125 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded;
5126 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5127 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
5128 if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,\
5129 e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded, serviceUpdate.recvRanFuncList.ranFunToBeAdded) !=ROK)
5135 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified)
5138 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsModified;
5139 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5140 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
5141 if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,
5142 e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeModified, serviceUpdate.recvRanFuncList.ranFunToBeModified) !=ROK)
5148 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted)
5151 ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsDeleted;
5152 ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
5153 ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctionsID_List;
5154 if(BuildRanFunctionDeleteList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List,\
5155 serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted, serviceUpdate.recvRanFuncList.ranFunToBeDeleted) != ROK)
5160 /* Prints the Msg formed */
5161 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
5163 memset(encBuf, 0, ENC_BUF_MAX_LEN);
5165 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
5166 if(encRetVal.encoded == ENCODE_FAIL)
5168 DU_LOG("\nERROR --> E2AP : Could not encode RicServiceUpdateuest structure (at %s)\n",\
5169 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5174 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicServiceUpdateuest\n");
5175 #ifdef DEBUG_ASN_PRINT
5176 for(int i=0; i< encBufSize; i++)
5178 printf("%x",encBuf[i]);
5182 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
5184 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
5193 if(serviceUpdate.dir == E2_NODE_INITIATED)
5195 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
5196 duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5200 duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId = transId;
5201 duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
5203 duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.dir = serviceUpdate.dir;
5204 duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.transId =transId;
5205 memcpy(&duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.recvRanFuncList, &serviceUpdate.recvRanFuncList, sizeof(E2TmpRanFunList));
5207 FreeRicServiceUpdate(e2apMsg);
5210 /******************************************************************
5212 * @brief Processes RIC service Query sent by RIC
5216 * Function : procRicServiceQuery
5218 * Functionality: Processes RIC service Query sent by RIC
5220 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5221 * @return ROK - success
5224 * ****************************************************************/
5226 void procRicServiceQuery(E2AP_PDU_t *e2apMsg)
5229 uint16_t arrIdx =0, ranFuncIdx=0,tmpIdx=0;
5230 uint16_t id,revisionCcounter;
5231 bool tmpArray[MAX_RAN_FUNCTION] = {false};
5232 RICserviceQuery_t *ricServiceQuery=NULL;
5233 RicServiceUpdate ricUpdate;
5234 RANfunctionID_ItemIEs_t *ranFuncAddedItemIe;
5235 RANfunctionsID_List_t *ranFuncAddedList;
5237 DU_LOG("\nINFO --> E2AP : RIC Service Query received");
5238 memset(&ricUpdate, 0, sizeof(RicServiceUpdate));
5239 ricUpdate.dir = RIC_INITIATED;
5240 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
5242 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
5244 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
5246 /* TODO completing in next patch/gerrit */
5247 case ProtocolIE_IDE2_id_TransactionID:
5249 ricUpdate.transId = ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
5253 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5255 ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5256 if(ranFuncAddedList->list.array)
5258 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5260 if(ranFuncAddedList->list.array[ranFuncIdx])
5262 /* Using the RAN function Id, identify the RAN function to be modified or deleted. */
5264 ranFuncAddedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAddedList->list.array[ranFuncIdx];
5265 id = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionID;
5266 revisionCcounter = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision;
5268 if((id != duCb.e2apDb.ranFunction[id-1].id))
5270 action = CONFIG_DEL;
5272 else if((id == duCb.e2apDb.ranFunction[id-1].id)&&(revisionCcounter!=duCb.e2apDb.ranFunction[id-1].revisionCounter))
5274 action = CONFIG_MOD;
5277 if(action == CONFIG_DEL)
5279 ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].id = id;
5280 ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].revisionCounter = revisionCcounter;
5281 ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted++;
5283 else if(action == CONFIG_MOD)
5285 ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].id = id;
5286 ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].revisionCounter = revisionCcounter;
5287 ricUpdate.recvRanFuncList.numOfRanFunToBeModified++;
5290 /* If any ID is set to true, it means that the ID has been used in either modification or deletion list.
5291 * Else we will add the IDs into the added list */
5292 tmpArray[id-1] = true;
5301 /* Traversing the whole RAN function list in ducb to check if any new Ran function ids have been added. */
5302 for(arrIdx =0; arrIdx<MAX_RAN_FUNCTION; arrIdx++)
5304 tmpIdx= ricUpdate.recvRanFuncList.numOfRanFunToBeAdded;
5305 if((duCb.e2apDb.ranFunction[arrIdx].id >0)&&(!tmpArray[arrIdx]))
5307 ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[arrIdx].id;
5308 ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[arrIdx].revisionCounter;
5309 ricUpdate.recvRanFuncList.numOfRanFunToBeAdded++;
5313 if(BuildAndSendRicServiceUpdate(ricUpdate)!= ROK)
5315 DU_LOG("\nERROR --> E2AP : Failed to build and send ric service update message");
5318 freeAperDecodingOfRicServiceQuery(ricServiceQuery);
5321 /******************************************************************
5323 * @brief Deallocation of memory allocated by aper decoder for
5324 * RIC service update ack
5328 * Function : freeAperDecodingOfRicServiceUpdateAck
5330 * Functionality: Deallocation of memory allocated by aper decoder
5331 * for RIC service update ack
5333 * @params[in] RICserviceUpdateAck_t *ricServiceAck;
5336 * ****************************************************************/
5338 void freeAperDecodingOfRicServiceUpdateAck(RICserviceUpdateAcknowledge_t *ricServiceAck)
5340 uint8_t arrIdx=0,ranFuncIdx=0;
5341 RANfunctionsID_List_t *ranFuncAddedList=NULL;
5345 if(ricServiceAck->protocolIEs.list.array)
5347 for(arrIdx=0; arrIdx<ricServiceAck->protocolIEs.list.count; arrIdx++)
5349 if(ricServiceAck->protocolIEs.list.array[arrIdx])
5351 switch(ricServiceAck->protocolIEs.list.array[arrIdx]->id)
5353 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5355 ranFuncAddedList= &ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
5356 if(ranFuncAddedList->list.array)
5358 for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
5360 free(ranFuncAddedList->list.array[ranFuncIdx]);
5362 free(ranFuncAddedList->list.array);
5369 free(ricServiceAck->protocolIEs.list.array[arrIdx]);
5372 free(ricServiceAck->protocolIEs.list.array);
5377 /******************************************************************
5379 * @brief Processes RIC service update ack sent by RIC
5383 * Function : procRicServiceUpdateAck
5385 * Functionality: Processes RIC service update ack sent by RIC
5387 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5388 * @return ROK - success
5391 * ****************************************************************/
5393 void procRicServiceUpdateAck(E2AP_PDU_t *e2apMsg)
5395 uint8_t arrIdx =0, transId =0;
5396 uint16_t id =0, tmpIdx=0, ranFuncIdx=0;
5397 RicServiceUpdate serviceUpdate;
5398 RANfunctionsIDcause_List_t *rejectedList=NULL;
5399 RICserviceUpdateAcknowledge_t *ricServiceAck=NULL;
5400 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
5402 DU_LOG("\nINFO --> E2AP : RIC service update ack received");
5403 memset(&serviceUpdate, 0, sizeof(RicServiceUpdate));
5404 ricServiceAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
5406 for(arrIdx=0; arrIdx<ricServiceAck->protocolIEs.list.count; arrIdx++)
5408 switch(ricServiceAck->protocolIEs.list.array[arrIdx]->id)
5410 case ProtocolIE_IDE2_id_TransactionID:
5412 transId = ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
5413 if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
5414 (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
5416 memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
5418 else if((duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId == transId) &&\
5419 (duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
5421 memset(&duCb.e2apDb.e2TransInfo.ricInitTransaction[transId], 0, sizeof(E2TransInfo));
5425 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
5431 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
5434 case ProtocolIE_IDE2_id_RANfunctionsRejected:
5436 rejectedList= &ricServiceAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
5437 if(rejectedList->list.array)
5439 for(ranFuncIdx=0;ranFuncIdx<rejectedList->list.count; ranFuncIdx++)
5441 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)rejectedList->list.array[ranFuncIdx];
5442 id = ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID;
5443 tmpIdx= serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded;
5444 serviceUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[id-1].id;
5445 serviceUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[id-1].revisionCounter;
5446 serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded++;
5455 if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
5457 serviceUpdate.dir = E2_NODE_INITIATED;
5458 BuildAndSendRicServiceUpdate(serviceUpdate);
5460 freeAperDecodingOfRicServiceUpdateAck(ricServiceAck);
5463 /******************************************************************
5465 * @brief Deallocation of memory allocated by aper decoder for
5466 * RIC service update failure
5470 * Function : freeAperDecodingOfRicServiceUpdateFailure
5472 * Functionality: Deallocation of memory allocated by aper decoder
5473 * for RIC service update failure
5475 * @params[in] RICserviceUpdateFailure_t *ricServiceFailure;
5478 * ****************************************************************/
5480 void freeAperDecodingOfRicServiceUpdateFailure(RICserviceUpdateFailure_t *ricServiceFailure)
5484 if(ricServiceFailure)
5486 if(ricServiceFailure->protocolIEs.list.array)
5488 for(arrIdx=0; arrIdx<ricServiceFailure->protocolIEs.list.count; arrIdx++)
5490 if(ricServiceFailure->protocolIEs.list.array[arrIdx])
5492 free(ricServiceFailure->protocolIEs.list.array[arrIdx]);
5495 free(ricServiceFailure->protocolIEs.list.array);
5500 /******************************************************************
5502 * @brief Processes RIC service update failure sent by RIC
5506 * Function : procRicServiceUpdateFailure
5508 * Functionality: Processes RIC service update failure sent by RIC
5510 * @params[in] E2AP_PDU_t ASN decoded E2AP message
5511 * @return ROK - success
5514 * ****************************************************************/
5516 void procRicServiceUpdateFailure(E2AP_PDU_t *e2apMsg)
5518 uint8_t arrIdx =0, timerValue=0;
5519 RICserviceUpdateFailure_t *ricServiceFailure=NULL;
5521 DU_LOG("\nINFO --> E2AP : RIC service update failure received");
5522 ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
5524 for(arrIdx=0; arrIdx<ricServiceFailure->protocolIEs.list.count; arrIdx++)
5526 switch(ricServiceFailure->protocolIEs.list.array[arrIdx]->id)
5528 case ProtocolIE_IDE2_id_TransactionID:
5532 case ProtocolIE_IDE2_id_TimeToWaitE2:
5534 timerValue = convertE2WaitTimerEnumToValue(ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
5535 if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer), EVENT_RIC_SERVICE_UPDATE_TMR)) == FALSE)
5537 duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer), EVENT_RIC_SERVICE_UPDATE_TMR, timerValue);
5541 DU_LOG("\nERROR --> E2AP : EVENT_RIC_SERVICE_UPDATE_TMR timer is already running");
5546 case ProtocolIE_IDE2_id_CauseE2:
5553 freeAperDecodingOfRicServiceUpdateFailure(ricServiceFailure);
5556 /******************************************************************
5558 * @brief DU Send E2 Node Configuration Update
5562 * Function : duSendE2NodeConfigurationUpdate
5564 * Functionality: DU Send E2 Node Configuration Update
5566 * @return ROK - success
5569 * ****************************************************************/
5571 uint8_t duSendE2NodeConfigurationUpdate()
5573 E2NodeConfigList e2NodeList;
5574 CmLList *node =NULL;
5575 E2NodeComponent *e2NodeComponentInfo=NULL;
5577 memset(&e2NodeList, 0, sizeof(E2NodeConfigList));
5578 CM_LLIST_FIRST_NODE(&duCb.e2apDb.e2NodeComponentList, node);
5581 e2NodeComponentInfo = (E2NodeComponent*)node->node;
5583 if(e2NodeComponentInfo->componentRequestPart && e2NodeComponentInfo->componentResponsePart)
5585 switch(e2NodeComponentInfo->componentActionType)
5587 case E2_NODE_COMPONENT_ADD:
5589 e2NodeList.addE2Node[e2NodeList.addE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
5590 e2NodeList.addE2Node[e2NodeList.addE2NodeCount].actionType = e2NodeComponentInfo->componentActionType;
5591 e2NodeList.removeE2NodeCount++;
5594 case E2_NODE_COMPONENT_UPDATE:
5596 e2NodeList.updateE2Node[e2NodeList.updateE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
5597 e2NodeList.updateE2Node[e2NodeList.updateE2NodeCount].actionType = e2NodeComponentInfo->componentActionType;
5598 e2NodeList.updateE2NodeCount++;
5602 case E2_NODE_COMPONENT_DEL:
5604 e2NodeList.removeE2Node[e2NodeList.removeE2NodeCount].interface = e2NodeComponentInfo->interfaceType;
5605 e2NodeList.removeE2Node[e2NodeList.removeE2NodeCount].actionType = e2NodeComponentInfo->componentActionType;
5606 e2NodeList.removeE2NodeCount++;
5614 if(BuildAndSendE2NodeConfigUpdate(&e2NodeList) !=ROK)
5616 DU_LOG("\nERROR --> E2AP : Failed to build and send e2 node config update message to RIC_stub");
5622 /*******************************************************************
5624 * @brief Free RIC Subscription Modification Required
5628 * Function : FreeRicSubsModRequired
5630 * Functionality: Freqq RIC Subscription Modification required
5632 * @param E2AP Message PDU to be freed
5635 ******************************************************************/
5636 void FreeRicSubsModRequired(E2AP_PDU_t *e2apMsg)
5638 uint8_t ieIdx = 0, arrIdx = 0;
5639 RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP;
5640 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
5641 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
5642 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
5646 if(e2apMsg->choice.initiatingMessage)
5648 ricSubsModReqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired;
5649 if(ricSubsModReqd->protocolIEs.list.array)
5651 for(ieIdx = 0; ieIdx < ricSubsModReqd->protocolIEs.list.count; ieIdx++)
5653 if(ricSubsModReqd->protocolIEs.list.array[ieIdx])
5655 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
5656 switch(ricSubsModReqdIe->id)
5658 case ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List:
5660 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
5661 if(actionToBeModList->list.array)
5663 for(arrIdx = 0; arrIdx < actionToBeModList->list.count; arrIdx++)
5665 DU_FREE(actionToBeModList->list.array[arrIdx], \
5666 sizeof(RICaction_RequiredToBeModified_ItemIEs_t));
5668 DU_FREE(actionToBeModList->list.array, actionToBeModList->list.size);
5673 case ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List:
5675 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
5676 if(actionToBeRmvList->list.array)
5678 for(arrIdx = 0; arrIdx < actionToBeRmvList->list.count; arrIdx++)
5680 DU_FREE(actionToBeRmvList->list.array[arrIdx], \
5681 sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t));
5683 DU_FREE(actionToBeRmvList->list.array, actionToBeRmvList->list.size);
5691 DU_FREE(ricSubsModReqd->protocolIEs.list.array[ieIdx], \
5692 sizeof(RICsubscriptionModificationRequired_IEs_t));
5695 DU_FREE(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size);
5697 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5699 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
5703 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
5704 * However, E2SM-KPM supports only RIC Report service.
5705 * Hence there is no subsequent action in RIC subscription that may require modification.
5706 * So commenting the action-modification IEs for the time being
5709 /*******************************************************************
5711 * @brief Fill Action required to be modified list
5715 * Function : FillActionReqdToBeModList
5717 * Functionality: Fill Action required to be modified list
5719 * @param RIC Actions Required To Be Modified List to be filled
5720 * Number of actions to be modified
5721 * RIC Subscription DB
5722 * @return ROK - success
5725 ******************************************************************/
5726 uint8_t FillActionReqdToBeModList(RICactions_RequiredToBeModified_List_t *actionToBeModList, uint8_t numActionsMod, \
5727 RicSubscription *ricSubscription)
5729 uint8_t arrIdx = 0, actionIdx = 0;
5730 RICaction_RequiredToBeModified_ItemIEs_t *actionToBeMod = NULL;
5732 actionToBeModList->list.count = numActionsMod;
5733 actionToBeModList->list.size = numActionsMod * sizeof(RICaction_RequiredToBeModified_ItemIEs_t *);
5734 DU_ALLOC(actionToBeModList->list.array, actionToBeModList->list.size);
5735 if(!actionToBeModList->list.array)
5737 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
5742 for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
5744 if(ricSubscription->actionSequence[actionIdx].action == CONFIG_MOD)
5746 DU_ALLOC(actionToBeModList->list.array[arrIdx], sizeof(RICaction_RequiredToBeModified_ItemIEs_t));
5747 if(!actionToBeModList->list.array[arrIdx])
5749 DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d", __func__, __LINE__);
5752 actionToBeMod = (RICaction_RequiredToBeModified_ItemIEs_t *)actionToBeModList->list.array[arrIdx];
5754 actionToBeMod->id = ProtocolIE_IDE2_id_RICaction_RequiredToBeModified_Item;
5755 actionToBeMod->criticality = CriticalityE2_reject;
5756 actionToBeMod->value.present = \
5757 RICaction_RequiredToBeModified_ItemIEs__value_PR_RICaction_RequiredToBeModified_Item;
5758 actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricActionID = \
5759 ricSubscription->actionSequence[actionIdx].actionId;
5760 actionToBeMod->value.choice.RICaction_RequiredToBeModified_Item.ricTimeToWait = RICtimeToWait_w5ms;
5770 /*******************************************************************
5772 * @brief Fill Action required to be removed list
5776 * Function : FillActionReqdToBeRmvList
5778 * Functionality: Fill Action required to be removed list
5780 * @param RIC Actions Required To Be Removed List to be filled
5781 * Number of actions to be removed
5782 * RIC Subscription DB
5783 * @return ROK - success
5786 ******************************************************************/
5787 uint8_t FillActionReqdToBeRmvList(RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList, uint8_t numActionsRmv, \
5788 RicSubscription *ricSubscription)
5790 uint8_t arrIdx = 0, actionIdx = 0;
5791 RICaction_RequiredToBeRemoved_ItemIEs_t *actionToBeRmv = NULL;
5793 actionToBeRmvList->list.count = numActionsRmv;
5794 actionToBeRmvList->list.size = numActionsRmv * sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t *);
5795 DU_ALLOC(actionToBeRmvList->list.array, actionToBeRmvList->list.size);
5796 if(!actionToBeRmvList->list.array)
5798 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
5803 for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
5805 if(ricSubscription->actionSequence[actionIdx].action == CONFIG_DEL)
5807 DU_ALLOC(actionToBeRmvList->list.array[arrIdx], sizeof(RICaction_RequiredToBeRemoved_ItemIEs_t));
5808 if(!actionToBeRmvList->list.array[arrIdx])
5810 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
5813 actionToBeRmv = (RICaction_RequiredToBeRemoved_ItemIEs_t *)actionToBeRmvList->list.array[arrIdx];
5815 actionToBeRmv->id = ProtocolIE_IDE2_id_RICaction_RequiredToBeRemoved_Item;
5816 actionToBeRmv->criticality = CriticalityE2_reject;
5817 actionToBeRmv->value.present = \
5818 RICaction_RequiredToBeRemoved_ItemIEs__value_PR_RICaction_RequiredToBeRemoved_Item;
5819 actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.ricActionID = \
5820 ricSubscription->actionSequence[actionIdx].actionId;
5821 fillE2Cause(&actionToBeRmv->value.choice.RICaction_RequiredToBeRemoved_Item.cause, \
5822 ricSubscription->actionSequence[actionIdx].failureCause);
5831 /*******************************************************************
5833 * @brief Fill RIC Subscription Modification Required IEs
5837 * Function : FillRicSubsModRequired
5839 * Functionality: Fill RIC Subscription Modification Required IEs
5841 * @param RIC Subscription Modification Required IEs to be filled
5842 * RIC Subscription DB
5843 * @return ROK - success
5846 ******************************************************************/
5847 uint8_t FillRicSubsModRequired(RICsubscriptionModificationRequired_t *ricSubsModReqd, RicSubscription *ricSubscription)
5849 uint8_t ieIdx = 0, elementCnt=0, actionIdx = 0;
5850 uint8_t numActionsMod = 0, numActionsRmv = 0;
5851 RICsubscriptionModificationRequired_IEs_t *ricSubsModReqdIe = NULLP;
5852 RICactions_RequiredToBeRemoved_List_t *actionToBeRmvList = NULLP;
5854 /* Unused in case of E2SM-KPM */
5856 RICactions_RequiredToBeModified_List_t *actionToBeModList = NULLP;
5859 /* Count number of Actions to be modified or deleted */
5860 for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
5862 if(ricSubscription->actionSequence[actionIdx].action == CONFIG_MOD)
5864 else if(ricSubscription->actionSequence[actionIdx].action == CONFIG_DEL)
5868 /* Count number of IEs to be added to messages */
5875 ricSubsModReqd->protocolIEs.list.count = elementCnt;
5876 ricSubsModReqd->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionModificationRequired_IEs_t *);
5877 DU_ALLOC(ricSubsModReqd->protocolIEs.list.array, ricSubsModReqd->protocolIEs.list.size);
5878 if(!ricSubsModReqd->protocolIEs.list.array)
5880 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
5884 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
5886 DU_ALLOC(ricSubsModReqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionModificationRequired_IEs_t));
5887 if(!ricSubsModReqd->protocolIEs.list.array[ieIdx])
5889 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
5894 /* RIC Request ID */
5896 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
5897 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICrequestID;
5898 ricSubsModReqdIe->criticality = CriticalityE2_reject;
5899 ricSubsModReqdIe->value.present = RICsubscriptionModificationRequired_IEs__value_PR_RICrequestID;
5900 ricSubsModReqdIe->value.choice.RICrequestID.ricRequestorID = ricSubscription->requestId.requestorId;
5901 ricSubsModReqdIe->value.choice.RICrequestID.ricInstanceID = ricSubscription->requestId.instanceId;
5903 /* RAN Function ID */
5905 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
5906 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RANfunctionID;
5907 ricSubsModReqdIe->criticality = CriticalityE2_reject;
5908 ricSubsModReqdIe->value.present = RICsubscriptionModificationRequired_IEs__value_PR_RANfunctionID;
5909 ricSubsModReqdIe->value.choice.RANfunctionID = ricSubscription->ranFuncId;
5911 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
5912 * However, E2SM-KPM supports only RIC Report service.
5913 * Hence there is no subsequent action in RIC subscription that may require modification.
5914 * So commenting the action-modification IEs for the time being
5917 /* RIC Actions Required to be Modified */
5921 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
5922 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICactionsRequiredToBeModified_List;
5923 ricSubsModReqdIe->criticality = CriticalityE2_reject;
5924 ricSubsModReqdIe->value.present = \
5925 RICsubscriptionModificationRequired_IEs__value_PR_RICactions_RequiredToBeModified_List;
5926 actionToBeModList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeModified_List;
5928 if(FillActionReqdToBeModList(actionToBeModList, numActionsMod, ricSubscription) != ROK)
5930 DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be modified list", __func__);
5936 /* RIC Actions Required to be removed */
5940 ricSubsModReqdIe = ricSubsModReqd->protocolIEs.list.array[ieIdx];
5941 ricSubsModReqdIe->id = ProtocolIE_IDE2_id_RICactionsRequiredToBeRemoved_List;
5942 ricSubsModReqdIe->criticality = CriticalityE2_reject;
5943 ricSubsModReqdIe->value.present = \
5944 RICsubscriptionModificationRequired_IEs__value_PR_RICactions_RequiredToBeRemoved_List;
5945 actionToBeRmvList = &ricSubsModReqdIe->value.choice.RICactions_RequiredToBeRemoved_List;
5947 if(FillActionReqdToBeRmvList(actionToBeRmvList, numActionsRmv, ricSubscription) != ROK)
5949 DU_LOG("\nERROR --> E2AP : %s: Failed to fill actions required to be removed list", __func__);
5957 /*******************************************************************
5959 * @brief Builds and Send RIC Subscription Modification Required
5964 * Function : BuildAndSendRicSubsModRequired
5966 * Functionality: Builds and Send RIC Subscription Modification
5969 * @param RIC Subscription DB
5970 * @return ROK - success
5973 ******************************************************************/
5974 uint8_t BuildAndSendRicSubsModRequired(RicSubscription *ricSubscription)
5976 uint8_t ret = RFAILED;
5977 E2AP_PDU_t *e2apMsg = NULLP;
5978 RICsubscriptionModificationRequired_t *ricSubsModReqd = NULLP;
5979 asn_enc_rval_t encRetVal; /* Encoder return value */
5981 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Modification Required \n");
5984 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
5985 if(e2apMsg == NULLP)
5987 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
5991 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
5992 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
5993 if(e2apMsg->choice.initiatingMessage == NULLP)
5995 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed at line %d", __func__, __LINE__);
5998 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
5999 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionModificationRequired;
6000 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionModificationRequired;
6002 ricSubsModReqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionModificationRequired;
6004 if(FillRicSubsModRequired(ricSubsModReqd, ricSubscription) != ROK)
6006 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Subscription Modification Required IEs", __func__);
6011 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6013 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6015 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6016 if(encRetVal.encoded == ENCODE_FAIL)
6018 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Modifiction Required structure (at %s)\n",\
6019 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6024 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Modification Required \n");
6025 #ifdef DEBUG_ASN_PRINT
6026 for(int i=0; i< encBufSize; i++)
6028 printf("%x",encBuf[i]);
6032 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
6034 DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Modification Required failed");
6041 /* Free RIC Subscription modification required */
6042 FreeRicSubsModRequired(e2apMsg);
6046 /*******************************************************************
6048 * @brief Free APER decoding of RIC Subscription Modification Confirm
6052 * Function : freeAperDecodingOfRicSubsModConfirm
6054 * Functionality: Free APER decoding of RIC Subscription
6055 * Modification Confirm
6057 * @param E2AP Message PDU
6060 ******************************************************************/
6061 void freeAperDecodingOfRicSubsModConfirm(E2AP_PDU_t *e2apMsg)
6063 uint8_t ieIdx = 0, arrIdx=0;
6064 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
6065 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
6066 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
6067 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
6068 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
6069 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
6071 if(e2apMsg && e2apMsg->choice.successfulOutcome)
6073 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
6074 if(ricSubsModCfm->protocolIEs.list.array)
6076 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
6078 if(ricSubsModCfm->protocolIEs.list.array[ieIdx])
6080 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
6081 switch(ricSubsModCfmIe->id)
6083 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
6085 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
6086 if(modCfmList->list.array)
6088 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
6090 if(modCfmList->list.array[arrIdx])
6091 free(modCfmList->list.array[arrIdx]);
6093 free(modCfmList->list.array);
6098 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
6100 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
6101 if(modRefusedList->list.array)
6103 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
6105 if(modRefusedList->list.array[arrIdx])
6106 free(modRefusedList->list.array[arrIdx]);
6108 free(modRefusedList->list.array);
6113 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
6115 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
6116 if(rmvCfmList->list.array)
6118 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
6120 if(rmvCfmList->list.array[arrIdx])
6121 free(rmvCfmList->list.array[arrIdx]);
6123 free(rmvCfmList->list.array);
6128 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
6130 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
6131 if(rmvFailList->list.array)
6133 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
6135 if(rmvFailList->list.array[arrIdx])
6136 free(rmvFailList->list.array[arrIdx]);
6138 free(rmvFailList->list.array);
6147 free(ricSubsModCfmIe);
6150 free(ricSubsModCfm->protocolIEs.list.array);
6155 /*******************************************************************
6157 * @brief Process RIC Subscription Modification Confirm Message
6161 * Function : procRicSubscriptionModificationConfirm
6163 * Functionality: Process RIC Subscription Modification Confirm
6164 * Message received from RIC.
6166 * @param E2AP Message PDU
6169 ******************************************************************/
6170 void procRicSubscriptionModificationConfirm(E2AP_PDU_t *e2apMsg)
6172 uint8_t actionId = 0, ieIdx = 0, arrIdx = 0;
6173 uint16_t ranFuncId = 0;
6174 bool procFailure = false;
6175 RicRequestId ricReqId;
6176 RanFunction *ranFuncDb = NULLP;
6177 CmLList *ricSubsNode = NULLP;
6178 RicSubscription *ricSubsDb = NULLP;
6179 ActionInfo *actionDb = NULLP;
6181 RICsubscriptionModificationConfirm_t *ricSubsModCfm = NULLP;
6182 RICsubscriptionModificationConfirm_IEs_t *ricSubsModCfmIe = NULLP;
6184 /* Not used in case of E2SM-KPM */
6186 RICactions_ConfirmedForModification_List_t *modCfmList = NULLP;
6187 RICaction_ConfirmedForModification_ItemIEs_t *modCfmListItem = NULLP;
6189 RICactions_RefusedToBeModified_List_t *modRefusedList = NULLP;
6190 RICaction_RefusedToBeModified_ItemIEs_t *modRefusedListItem = NULLP;
6193 RICactions_ConfirmedForRemoval_List_t *rmvCfmList = NULLP;
6194 RICaction_ConfirmedForRemoval_ItemIEs_t *rmvCfmListItem = NULLP;
6196 RICactions_RefusedToBeRemoved_List_t *rmvFailList = NULLP;
6197 RICaction_RefusedToBeRemoved_ItemIEs_t *rmvFailListItem = NULLP;
6199 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Confirm", __func__);
6204 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
6208 if(!e2apMsg->choice.successfulOutcome)
6210 DU_LOG("\nERROR --> E2AP : %s: Successful Outcome in E2AP message is NULL", __func__);
6214 ricSubsModCfm = &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionModificationConfirm;
6215 if(!ricSubsModCfm->protocolIEs.list.array)
6217 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
6221 for(ieIdx = 0; ieIdx < ricSubsModCfm->protocolIEs.list.count; ieIdx++)
6223 if(!ricSubsModCfm->protocolIEs.list.array[ieIdx])
6225 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
6229 ricSubsModCfmIe = ricSubsModCfm->protocolIEs.list.array[ieIdx];
6230 switch(ricSubsModCfmIe->id)
6232 case ProtocolIE_IDE2_id_RICrequestID:
6234 memset(&ricReqId, 0, sizeof(RicRequestId));
6235 ricReqId.requestorId = ricSubsModCfmIe->value.choice.RICrequestID.ricRequestorID;
6236 ricReqId.instanceId = ricSubsModCfmIe->value.choice.RICrequestID.ricInstanceID;
6240 case ProtocolIE_IDE2_id_RANfunctionID:
6242 ranFuncId = ricSubsModCfmIe->value.choice.RANfunctionID;
6243 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
6246 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
6251 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
6254 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
6255 __func__, ricReqId.requestorId, ricReqId.instanceId);
6263 /* A RIC Subscription includes RIC subsequent action only for RIC Insert service.
6264 * However, E2SM-KPM supports only RIC Report service.
6265 * Hence there is no subsequent action in RIC subscription that may require modification.
6266 * So commenting the action-modification IEs for the time being
6269 case ProtocolIE_IDE2_id_RICactionsConfirmedForModification_List:
6271 modCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForModification_List;
6272 for(arrIdx = 0; arrIdx < modCfmList->list.count; arrIdx++)
6274 modCfmListItem = (RICaction_ConfirmedForModification_ItemIEs_t *)modCfmList->list.array[arrIdx];
6275 actionId = modCfmListItem->value.choice.RICaction_ConfirmedForModification_Item.ricActionID;
6277 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb);
6280 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6284 actionDb->action = CONFIG_UNKNOWN;
6285 /* Further handling can be added here in future once the
6286 * use case of this procedure is identified */
6293 case ProtocolIE_IDE2_id_RICactionsRefusedToBeModified_List:
6295 modRefusedList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeModified_List;
6296 for(arrIdx = 0; arrIdx < modRefusedList->list.count; arrIdx++)
6298 modRefusedListItem = (RICaction_RefusedToBeModified_ItemIEs_t *)modRefusedList->list.array[arrIdx];
6299 actionId = modRefusedListItem->value.choice.RICaction_RefusedToBeModified_Item.ricActionID;
6300 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb);
6303 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6307 /* Spec doesnt mention if in case of failure, DU should retry for modify action
6308 * Hence, chaging the action from CONFIG_MOD to CONFIG_UNKNOWN
6310 actionDb->action = CONFIG_UNKNOWN;
6318 case ProtocolIE_IDE2_id_RICactionsConfirmedForRemoval_List:
6320 rmvCfmList = &ricSubsModCfmIe->value.choice.RICactions_ConfirmedForRemoval_List;
6321 for(arrIdx = 0; arrIdx < rmvCfmList->list.count; arrIdx++)
6323 rmvCfmListItem = (RICaction_ConfirmedForRemoval_ItemIEs_t *)rmvCfmList->list.array[arrIdx];
6324 actionId = rmvCfmListItem->value.choice.RICaction_ConfirmedForRemoval_Item.ricActionID;
6325 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb);
6328 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6332 deleteActionSequence(actionDb);
6334 ricSubsDb->numOfActions--;
6335 /* Further handling can include :
6336 * Deletion of this action from all DU layers
6344 case ProtocolIE_IDE2_id_RICactionsRefusedToBeRemoved_List:
6346 rmvFailList = &ricSubsModCfmIe->value.choice.RICactions_RefusedToBeRemoved_List;
6347 for(arrIdx = 0; arrIdx < rmvFailList->list.count; arrIdx++)
6349 rmvFailListItem = (RICaction_RefusedToBeRemoved_ItemIEs_t *)rmvFailList->list.array[arrIdx];
6350 actionId = rmvFailListItem->value.choice.RICaction_RefusedToBeRemoved_Item.ricActionID;
6351 actionDb = fetchActionInfoFromActionId(actionId, ricSubsDb);
6354 DU_LOG("\nERROR --> E2AP : %s: Action ID [%d] not found", __func__, actionId);
6358 actionDb->action = CONFIG_UNKNOWN;
6367 } /* End of switch for Protocol IE Id */
6371 } /* End of for loop for Protocol IE list */
6376 freeAperDecodingOfRicSubsModConfirm(e2apMsg);
6380 /******************************************************************
6381 * @brief Deallocate the memory allocated for E2 Reset Response
6385 * Function : FreeE2ResetResponse
6388 * - freeing the memory allocated for E2ResetResponse
6390 * @params[in] E2AP_PDU_t *e2apMsg
6391 * @return ROK - success
6394 * ****************************************************************/
6395 void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
6398 ResetResponseE2_t *resetResponse;
6400 if(e2apMsg != NULLP)
6402 if(e2apMsg->choice.successfulOutcome != NULLP)
6404 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
6405 if(resetResponse->protocolIEs.list.array)
6407 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
6409 if(resetResponse->protocolIEs.list.array[ieIdx])
6411 DU_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
6414 DU_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
6417 DU_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
6419 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
6423 /*******************************************************************
6425 * @brief Buld and send the E2 Reset Response msg
6429 * Function : BuildAndSendE2ResetResponse
6432 * - Buld and send the E2 Reset Response Message
6434 * @params[in] Trans Id
6435 * @return ROK - success
6438 * ****************************************************************/
6439 uint8_t BuildAndSendResetResponse(uint8_t transId)
6441 uint8_t ieIdx = 0, elementCnt = 0;
6442 uint8_t ret = RFAILED;
6443 E2AP_PDU_t *e2apMsg = NULLP;
6444 ResetResponseE2_t *resetResponse;
6445 asn_enc_rval_t encRetVal; /* Encoder return value */
6447 DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
6450 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6451 if(e2apMsg == NULLP)
6453 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
6456 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
6458 DU_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
6459 if(e2apMsg->choice.successfulOutcome == NULLP)
6461 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
6465 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset;
6466 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
6467 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2;
6468 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
6471 resetResponse->protocolIEs.list.count = elementCnt;
6472 resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *);
6473 DU_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
6474 if(!resetResponse->protocolIEs.list.array)
6476 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
6480 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
6482 DU_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
6483 if(!resetResponse->protocolIEs.list.array[ieIdx])
6485 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
6489 if(ieIdx < elementCnt)
6493 resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
6494 resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
6495 resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID;
6496 resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
6498 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6500 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6502 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6503 if(encRetVal.encoded == ENCODE_FAIL)
6505 DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
6506 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6511 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
6512 for(int i=0; i< encBufSize; i++)
6514 DU_LOG("%x",encBuf[i]);
6519 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
6521 DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
6529 FreeE2ResetResponse(e2apMsg);
6533 /******************************************************************
6535 * @brief Deallocation of memory allocated by aper decoder for reset req
6539 * Function : freeAperDecodingOfE2ResetReq
6541 * Functionality: Deallocation of memory allocated by aper decoder for
6544 * @params[in] Pointer to resetReq
6547 * ****************************************************************/
6548 void freeAperDecodingOfE2ResetReq(ResetRequestE2_t *resetReq)
6554 if(resetReq->protocolIEs.list.array)
6556 for(arrIdx=0; arrIdx<resetReq->protocolIEs.list.count; arrIdx++)
6558 if(resetReq->protocolIEs.list.array[arrIdx])
6560 free(resetReq->protocolIEs.list.array[arrIdx]);
6563 free(resetReq->protocolIEs.list.array);
6568 /*******************************************************************
6570 * @brief Process reset req received from RIC
6574 * Function : procE2ResetRequest
6576 * Functionality: Process reset req received from RIC
6578 * @param E2AP_PDU_t *e2apMsg
6581 ******************************************************************/
6583 void procE2ResetRequest(E2AP_PDU_t *e2apMsg)
6585 uint16_t ranFuncIdx=0;
6586 uint8_t arrIdx =0, transId =0;
6587 ResetRequestE2_t *resetReq;
6589 DU_LOG("\nINFO --> E2AP : E2 Reset request received");
6590 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
6592 for(arrIdx=0; arrIdx<resetReq->protocolIEs.list.count; arrIdx++)
6594 switch(resetReq->protocolIEs.list.array[arrIdx]->id)
6596 case ProtocolIE_IDE2_id_TransactionID:
6598 transId = resetReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
6602 case ProtocolIE_IDE2_id_CauseE2:
6604 for(ranFuncIdx=0; ranFuncIdx<MAX_RAN_FUNCTION; ranFuncIdx++)
6606 if(duCb.e2apDb.ranFunction[ranFuncIdx].id >0)
6608 deleteRicSubscriptionList(&(duCb.e2apDb.ranFunction[ranFuncIdx].subscriptionList));
6609 memset(&(duCb.e2apDb.ranFunction[ranFuncIdx].pendingSubsRspInfo), 0, MAX_PENDING_SUBSCRIPTION_RSP*sizeof(PendingSubsRspInfo));
6616 if(BuildAndSendResetResponse(transId) != ROK)
6618 DU_LOG("\nERROR --> E2AP : Failed to build and send reset response");
6620 freeAperDecodingOfE2ResetReq(resetReq);
6623 /*******************************************************************
6625 * @brief Free APER decoding of RIC Subscription Modification Refuse
6629 * Function : freeAperDecodingOfRicSubsModRefuse
6631 * Functionality: Free APER decoding of RIC Subscription
6632 * Modification Refuse
6634 * @param E2AP Message PDU
6637 ******************************************************************/
6638 void freeAperDecodingOfRicSubsModRefuse(E2AP_PDU_t *e2apMsg)
6641 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
6643 if(e2apMsg && e2apMsg->choice.unsuccessfulOutcome)
6645 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
6646 if(ricSubsModRefuse->protocolIEs.list.array)
6648 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
6650 if(ricSubsModRefuse->protocolIEs.list.array[ieIdx])
6651 free(ricSubsModRefuse->protocolIEs.list.array[ieIdx]);
6653 free(ricSubsModRefuse->protocolIEs.list.array);
6658 /*******************************************************************
6660 * @brief Process RIC Subscription Modification Refuse Message
6664 * Function : procRicSubscriptionModificationRefuse
6666 * Functionality: Process RIC Subscription Modification Refuse
6667 * Message received from RIC.
6669 * @param E2AP Message PDU
6672 ******************************************************************/
6673 void procRicSubscriptionModificationRefuse(E2AP_PDU_t *e2apMsg)
6676 uint16_t ranFuncId = 0;
6677 RicRequestId ricReqId;
6678 RICsubscriptionModificationRefuse_t *ricSubsModRefuse = NULLP;
6679 RICsubscriptionModificationRefuse_IEs_t *ricSubsModRefuseIe = NULLP;
6680 CauseE2_t *cause = NULLP;
6682 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Modification Refuse", __func__);
6687 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
6691 if(!e2apMsg->choice.unsuccessfulOutcome)
6693 DU_LOG("\nERROR --> E2AP : %s: Unsuccessful Outcome in E2AP message is NULL", __func__);
6697 ricSubsModRefuse = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICsubscriptionModificationRefuse;
6698 if(!ricSubsModRefuse->protocolIEs.list.array)
6700 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
6704 for(ieIdx = 0; ieIdx < ricSubsModRefuse->protocolIEs.list.count; ieIdx++)
6706 if(!ricSubsModRefuse->protocolIEs.list.array[ieIdx])
6708 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
6712 ricSubsModRefuseIe = ricSubsModRefuse->protocolIEs.list.array[ieIdx];
6713 switch(ricSubsModRefuseIe->id)
6715 case ProtocolIE_IDE2_id_RICrequestID:
6717 memset(&ricReqId, 0, sizeof(RicRequestId));
6718 ricReqId.requestorId = ricSubsModRefuseIe->value.choice.RICrequestID.ricRequestorID;
6719 ricReqId.instanceId = ricSubsModRefuseIe->value.choice.RICrequestID.ricInstanceID;
6723 case ProtocolIE_IDE2_id_RANfunctionID:
6725 ranFuncId = ricSubsModRefuseIe->value.choice.RANfunctionID;
6729 case ProtocolIE_IDE2_id_CauseE2:
6731 DU_LOG("\nDEBUG --> E2AP : %s: RIC subscriptiom modification refused for RIC_Requestor_ID [%d] \
6732 RIC_Instance_ID [%d] RAN_Function_ID [%d] ", __func__, ricReqId.requestorId, \
6733 ricReqId.instanceId, ranFuncId);
6735 cause = &ricSubsModRefuseIe->value.choice.CauseE2;
6736 printE2ErrorCause(cause);
6741 } /* End of switch for Protocol IE Id */
6742 } /* End of for loop for Protocol IE list */
6747 freeAperDecodingOfRicSubsModRefuse(e2apMsg);
6751 /*******************************************************************
6753 * @brief Free RIC Subscription Delete Required Message
6757 * Function : FreeRicSubscriptionDeleteRequired
6759 * Functionality: Free RIC Subscription Delete Required
6761 * @param E2AP Message PDU
6764 ******************************************************************/
6765 void FreeRicSubscriptionDeleteRequired(E2AP_PDU_t *e2apMsg, CmLListCp *ricSubsToBeDelList)
6767 uint8_t ieIdx = 0, arrIdx = 0;
6768 RICsubscriptionDeleteRequired_t *ricSubsDelRqd = NULLP;
6769 RICsubscriptionDeleteRequired_IEs_t *ricSubsDelRqdIe = NULLP;
6770 RICsubscription_List_withCause_t *ricSubsList = NULLP;
6771 CmLList *subsNode = NULLP;
6775 if(e2apMsg->choice.initiatingMessage)
6777 ricSubsDelRqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired;
6778 if(ricSubsDelRqd->protocolIEs.list.array)
6780 for(ieIdx = 0; ieIdx < ricSubsDelRqd->protocolIEs.list.count; ieIdx++)
6782 if(ricSubsDelRqd->protocolIEs.list.array[ieIdx])
6784 ricSubsDelRqdIe = ricSubsDelRqd->protocolIEs.list.array[ieIdx];
6785 switch(ricSubsDelRqdIe->id)
6787 case ProtocolIE_IDE2_id_RICsubscriptionToBeRemoved:
6789 ricSubsList = &ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause;
6790 if(ricSubsList->list.array)
6792 for(arrIdx = 0; arrIdx < ricSubsList->list.count; arrIdx++)
6794 DU_FREE(ricSubsList->list.array[ieIdx], sizeof(RICsubscription_withCause_ItemIEs_t));
6796 DU_FREE(ricSubsList->list.array, ricSubsList->list.size);
6801 DU_FREE(ricSubsDelRqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
6804 DU_FREE(ricSubsDelRqd->protocolIEs.list.array, ricSubsDelRqd->protocolIEs.list.size);
6806 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6808 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));;
6811 if(ricSubsToBeDelList)
6813 CM_LLIST_FIRST_NODE(ricSubsToBeDelList, subsNode);
6816 cmLListDelFrm(ricSubsToBeDelList, subsNode);
6817 DU_FREE(subsNode, sizeof(CmLList));
6818 CM_LLIST_FIRST_NODE(ricSubsToBeDelList, subsNode);
6823 /*******************************************************************
6825 * @brief Fill list of RIC subscriptions required to be deleted
6826 * with the cause of deletion
6830 * Function : fillRicSubsListWithCause
6832 * Functionality: Fill list of RIC subscriptions required to be
6833 * deleted with the cause of deletion
6835 * @param E2AP Message PDU
6838 ******************************************************************/
6839 uint8_t fillRicSubsListWithCause(RICsubscription_List_withCause_t *ricSubsList, CmLListCp ricSubsToBeDelList)
6842 CmLList *subsNode = NULLP;
6843 RicSubscription *subsInfo = NULLP;
6844 RICsubscription_withCause_ItemIEs_t *subsItemIe = NULLP;
6845 RICsubscription_withCause_Item_t *subsItem = NULLP;
6847 ricSubsList->list.count = ricSubsToBeDelList.count;
6848 ricSubsList->list.size = ricSubsList->list.count * sizeof(RICsubscription_withCause_ItemIEs_t *);
6849 DU_ALLOC(ricSubsList->list.array, ricSubsList->list.size);
6850 if(!ricSubsList->list.array)
6852 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
6856 CM_LLIST_FIRST_NODE(&ricSubsToBeDelList, subsNode);
6857 while(subsNode && (ieIdx < ricSubsList->list.count))
6859 subsInfo = (RicSubscription *)subsNode->node;
6860 DU_ALLOC(ricSubsList->list.array[ieIdx], sizeof(RICsubscription_withCause_ItemIEs_t));
6861 if(!ricSubsList->list.array[ieIdx])
6863 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
6867 subsItemIe = (RICsubscription_withCause_ItemIEs_t *)ricSubsList->list.array[ieIdx];
6868 subsItemIe->id = ProtocolIE_IDE2_id_RICsubscription_withCause_Item;
6869 subsItemIe->criticality = CriticalityE2_ignore;
6870 subsItemIe->value.present = RICsubscription_withCause_ItemIEs__value_PR_RICsubscription_withCause_Item;
6872 subsItem = & subsItemIe->value.choice.RICsubscription_withCause_Item;
6873 subsItem->ricRequestID.ricRequestorID = subsInfo->requestId.requestorId;
6874 subsItem->ricRequestID.ricInstanceID = subsInfo->requestId.instanceId;
6875 subsItem->ranFunctionID = subsInfo->ranFuncId;
6876 fillE2Cause(&subsItem->cause, subsInfo->failureCause);
6879 subsNode = subsNode->next;
6885 /*******************************************************************
6887 * @brief Builds and Send RIC Subscription delete required
6891 * Function : BuildAndSendRicSubscriptionDeleteRequired
6893 * Functionality: Build and send RIC subscription delete required.
6894 * There can be 2 approaches to trigger following. One of these
6895 * approaches may/may not be implemented in future:
6896 * 1. It can be triggerred immediately when a RIC subscription's
6897 * End Time has expired. In this case, only this subscription's
6898 * info will be sent in this message.
6899 * Since we have not yet added support to execute RIC
6900 * Subscription based on Start Time and End Timer, this message is
6901 * not triggered anywhere from DU APP yet.
6902 * 2. Another approach is to have a periodic timer to check subscription
6903 * status running in background.
6904 * When RIC Subscription End Time expires, this subscription is
6905 * marked to be deleted. Later when this background timer expires,
6906 * a RIC Subscription delete required is sent with all the
6907 * subscription's info which is marked to be deleted.
6908 * The following function is implemented keeping in mind the second
6912 * @return ROK - success
6915 ******************************************************************/
6916 uint8_t BuildAndSendRicSubscriptionDeleteRequired()
6918 uint8_t elementCnt = 0, ieIdx = 0, ret = RFAILED;
6919 E2AP_PDU_t *e2apMsg = NULLP;
6920 RICsubscriptionDeleteRequired_t *ricSubsDelRqd = NULLP;
6921 RICsubscriptionDeleteRequired_IEs_t *ricSubsDelRqdIe = NULLP;
6922 asn_enc_rval_t encRetVal; /* Encoder return value */
6923 CmLListCp ricSubsToBeDelList;
6927 /* Check if there are any RIC subscriptions to be deleted */
6928 cmLListInit(&ricSubsToBeDelList);
6929 fetchRicSubsToBeDeleted(&ricSubsToBeDelList);
6930 if(ricSubsToBeDelList.count == 0)
6932 DU_LOG("\nDEBUG --> E2AP : %s: No RIC subscriptions are required to be deleted", __func__);
6936 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Delete Required Message\n");
6938 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
6939 if(e2apMsg == NULLP)
6941 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
6945 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
6946 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
6947 if(e2apMsg->choice.initiatingMessage == NULLP)
6949 DU_LOG("\nERROR --> E2AP : %s: Memory allocation for E2AP-PDU failed at line %d",__func__, __LINE__);
6952 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscriptionDeleteRequired;
6953 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
6954 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequired;
6956 ricSubsDelRqd = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequired;
6959 ricSubsDelRqd->protocolIEs.list.count = elementCnt;
6960 ricSubsDelRqd->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionDeleteRequired_IEs_t *);
6962 DU_ALLOC(ricSubsDelRqd->protocolIEs.list.array, ricSubsDelRqd->protocolIEs.list.size);
6963 if(ricSubsDelRqd->protocolIEs.list.array == NULLP)
6965 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for array elements at line %d",__func__, __LINE__);
6969 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
6971 DU_ALLOC(ricSubsDelRqd->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionDeleteRequired_IEs_t));
6972 if(ricSubsDelRqd->protocolIEs.list.array[ieIdx] == NULLP)
6974 DU_LOG("\nERROR --> E2AP : %s: Memory allocation failed for index [%d] at line %d", \
6975 __func__, ieIdx, __LINE__);
6979 if(ieIdx < elementCnt)
6983 ricSubsDelRqdIe = ricSubsDelRqd->protocolIEs.list.array[ieIdx];
6984 ricSubsDelRqdIe->id = ProtocolIE_IDE2_id_RICsubscriptionToBeRemoved;
6985 ricSubsDelRqdIe->criticality = CriticalityE2_ignore;
6986 ricSubsDelRqdIe->value.present = RICsubscriptionDeleteRequired_IEs__value_PR_RICsubscription_List_withCause;
6987 if(fillRicSubsListWithCause(&ricSubsDelRqdIe->value.choice.RICsubscription_List_withCause, ricSubsToBeDelList)\
6990 DU_LOG("\nERROR --> E2AP : %s: Failed to fill RIC Subscription list with cause", __func__);
6994 /* Prints the Msg formed */
6995 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
6996 memset(encBuf, 0, ENC_BUF_MAX_LEN);
6998 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
6999 if(encRetVal.encoded == ENCODE_FAIL)
7001 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Delete Required Message (at %s)\n",\
7002 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7007 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Subscription Delete Required Message \n");
7008 #ifdef DEBUG_ASN_PRINT
7009 for(int i=0; i< encBufSize; i++)
7011 printf("%x",encBuf[i]);
7016 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
7018 DU_LOG("\nERROR --> E2AP : Failed to send RIC Susbcription Delete Required Message");
7025 FreeRicSubscriptionDeleteRequired(e2apMsg, &ricSubsToBeDelList);
7029 /*******************************************************************
7031 * @brief Free RIC Subscription Delete Request Message
7035 * Function : freeAperDecodingOfRicSubsDeleteReq
7037 * Functionality: Free RIC Subscription Delete Request
7039 * @param E2AP Message PDU
7042 ******************************************************************/
7043 void freeAperDecodingOfRicSubsDeleteReq(E2AP_PDU_t *e2apMsg)
7046 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
7050 if(e2apMsg->choice.initiatingMessage)
7052 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
7053 if(ricSubsDelReq->protocolIEs.list.array)
7055 for(ieIdx = 0; ieIdx < ricSubsDelReq->protocolIEs.list.count; ieIdx++)
7057 if(ricSubsDelReq->protocolIEs.list.array[ieIdx])
7059 free(ricSubsDelReq->protocolIEs.list.array[ieIdx]);
7062 free(ricSubsDelReq->protocolIEs.list.array);
7068 /*******************************************************************
7070 * @brief Process RIC Subscription delete request
7074 * Function : procRicSubscriptionDeleteRequest
7076 * Functionality: Process RIC subscription delete request.
7077 * Fetch RAN Function and RIC subscription to be deleted.
7078 * Send statistics delete request to MAC for all action sequence
7079 * within this RIC subscription.
7081 * @params[in] E2AP PDU
7084 ******************************************************************/
7085 void procRicSubscriptionDeleteRequest(E2AP_PDU_t *e2apMsg)
7088 uint16_t ranFuncId = 0;
7089 bool procFailure = false;
7090 RicRequestId ricReqId;
7091 RanFunction *ranFuncDb = NULLP;
7092 CmLList *ricSubsNode = NULLP;
7093 RicSubscription *ricSubsDb = NULLP;
7094 RICsubscriptionDeleteRequest_t *ricSubsDelReq = NULLP;
7095 RICsubscriptionDeleteRequest_IEs_t *ricSubsDelReqIe = NULLP;
7097 DU_LOG("\nINFO --> E2AP : %s: Received RIC Subscription Delete Request", __func__);
7102 DU_LOG("\nERROR --> E2AP : %s: E2AP Message is NULL", __func__);
7106 if(!e2apMsg->choice.initiatingMessage)
7108 DU_LOG("\nERROR --> E2AP : %s: Initiating Message in E2AP PDU is NULL", __func__);
7112 ricSubsDelReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
7113 if(!ricSubsDelReq->protocolIEs.list.array)
7115 DU_LOG("\nERROR --> E2AP : %s: Array conatining E2AP message IEs is null", __func__);
7119 for(ieIdx = 0; ieIdx < ricSubsDelReq->protocolIEs.list.count; ieIdx++)
7121 if(!ricSubsDelReq->protocolIEs.list.array[ieIdx])
7123 DU_LOG("\nERROR --> E2AP : %s: IE at index [%d] in E2AP message IEs list is null", __func__, ieIdx);
7127 ricSubsDelReqIe = ricSubsDelReq->protocolIEs.list.array[ieIdx];
7128 switch(ricSubsDelReqIe->id)
7130 case ProtocolIE_IDE2_id_RICrequestID:
7132 memset(&ricReqId, 0, sizeof(RicRequestId));
7133 ricReqId.requestorId = ricSubsDelReqIe->value.choice.RICrequestID.ricRequestorID;
7134 ricReqId.instanceId = ricSubsDelReqIe->value.choice.RICrequestID.ricInstanceID;
7138 case ProtocolIE_IDE2_id_RANfunctionID:
7140 ranFuncId = ricSubsDelReqIe->value.choice.RANfunctionID;
7141 ranFuncDb = fetchRanFuncFromRanFuncId(ranFuncId);
7144 DU_LOG("\nERROR --> E2AP : %s: RAN Function ID [%d] not found", __func__, ranFuncId);
7149 ricSubsDb = fetchSubsInfoFromRicReqId(ricReqId, ranFuncDb, &ricSubsNode);
7152 DU_LOG("\nERROR --> E2AP : %s: RIC Subscription not found for Requestor_ID [%d] Instance_ID [%d]",\
7153 __func__, ricReqId.requestorId, ricReqId.instanceId);
7158 //TODO : Send statistics delete request to MAC
7164 } /* End of switch for Protocol IE Id */
7168 } /* End of for loop for Protocol IE list */
7173 freeAperDecodingOfRicSubsDeleteReq(e2apMsg);
7177 /*******************************************************************
7179 * @brief Handles received E2AP message and sends back response
7183 * Function : E2APMsgHdlr
7186 * - Decodes received E2AP control message
7187 * - Prepares response message, encodes and sends to SCTP
7190 * @return ROK - success
7193 * ****************************************************************/
7194 void E2APMsgHdlr(Buffer *mBuf)
7197 char *recvBuf = NULLP;
7199 MsgLen recvBufLen =0;
7200 E2AP_PDU_t *e2apMsg = NULLP;
7201 asn_dec_rval_t rval ={0}; /* Decoder return value */
7202 E2AP_PDU_t e2apasnmsg={0} ;
7204 DU_LOG("\nDEBUG --> E2AP : Received E2AP message buffer");
7205 ODU_PRINT_MSG(mBuf, 0,0);
7207 /* Copy mBuf into char array to decode it */
7208 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
7209 DU_ALLOC(recvBuf, (Size)recvBufLen);
7211 if(recvBuf == NULLP)
7213 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
7216 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
7218 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
7222 #ifdef DEBUG_ASN_PRINT
7223 printf("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
7224 for(i=0; i< recvBufLen; i++)
7226 printf("%x",recvBuf[i]);
7230 /* Decoding flat buffer into E2AP messsage */
7231 e2apMsg = &e2apasnmsg;
7232 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
7234 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
7235 DU_FREE(recvBuf, (Size)recvBufLen);
7237 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
7239 DU_LOG("\nERROR --> E2AP : ASN decode failed");
7243 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
7245 switch(e2apMsg->present)
7247 case E2AP_PDU_PR_unsuccessfulOutcome:
7249 switch(e2apMsg->choice.unsuccessfulOutcome->value.present)
7251 case UnsuccessfulOutcomeE2__value_PR_E2setupFailure:
7253 procE2SetupFailure(e2apMsg);
7256 case UnsuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateFailure:
7258 procE2NodeConfigUpdateFailure(e2apMsg);
7261 case UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure:
7263 procRicServiceUpdateFailure(e2apMsg);
7266 case UnsuccessfulOutcomeE2__value_PR_RICsubscriptionModificationRefuse:
7268 procRicSubscriptionModificationRefuse(e2apMsg);
7273 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_unsuccessfulOutcome [%d]",\
7274 e2apMsg->choice.unsuccessfulOutcome->value.present);
7278 free(e2apMsg->choice.unsuccessfulOutcome);
7281 case E2AP_PDU_PR_successfulOutcome:
7283 switch(e2apMsg->choice.successfulOutcome->value.present)
7285 case SuccessfulOutcomeE2__value_PR_E2setupResponse:
7289 procE2SetupRsp(e2apMsg);
7293 case SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge:
7295 DU_LOG("\nDEBUG --> E2AP : E2 node Config update ack message recevied");
7298 case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
7300 procResetResponse(e2apMsg);
7303 case SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge:
7305 procRicServiceUpdateAck(e2apMsg);
7308 case SuccessfulOutcomeE2__value_PR_RICsubscriptionModificationConfirm:
7310 procRicSubscriptionModificationConfirm(e2apMsg);
7316 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_successfulOutcome [%d]",\
7317 e2apMsg->choice.successfulOutcome->value.present);
7320 }/* End of switch(successfulOutcome) */
7321 free(e2apMsg->choice.successfulOutcome);
7325 case E2AP_PDU_PR_initiatingMessage:
7327 switch(e2apMsg->choice.initiatingMessage->value.present)
7329 case InitiatingMessageE2__value_PR_RICsubscriptionRequest:
7331 procRicSubscriptionRequest(e2apMsg);
7334 case InitiatingMessageE2__value_PR_RICserviceQuery:
7336 procRicServiceQuery(e2apMsg);
7339 case InitiatingMessageE2__value_PR_ErrorIndicationE2:
7341 DU_LOG("\nINFO --> E2AP : Error indication received");
7344 case InitiatingMessageE2__value_PR_ResetRequestE2:
7346 DU_LOG("\nINFO --> E2AP : Error indication received");
7347 procE2ResetRequest(e2apMsg);
7350 case InitiatingMessageE2__value_PR_RICsubscriptionDeleteRequest:
7352 DU_LOG("\nINFO --> E2AP : RIC Subscription Delete Request received");
7353 procRicSubscriptionDeleteRequest(e2apMsg);
7358 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\
7359 e2apMsg->choice.initiatingMessage->value.present);
7362 }/* End of switch(initiatingMessage) */
7363 free(e2apMsg->choice.initiatingMessage);
7368 DU_LOG("\nERROR --> E2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
7373 }/* End of switch(e2apMsg->present) */
7375 } /* End of E2APMsgHdlr */
7377 /**********************************************************************
7379 **********************************************************************/