/*******************************************************************
*
- * @brief Builds Ran function add list
+ * @brief Builds Ran function item
*
* @details
*
- * Function : BuildRanFunctionAddList
+ * Function : BuildRanFunctionItem
*
- * Functionality: Building RAN addition addition list
+ * Functionality: Building RAN function item
*
- * @params[in] RANfunctions_List_t *RANfunctions_List
+ * @params[in]
+ * RAN function item that has to be filled
+ * Stored RAN Function information
* @return ROK - success
* RFAILED - failure
*
******************************************************************/
-uint8_t BuildRanFunctionAddList(RANfunctions_List_t *ranFunctionsList)
+uint8_t BuildRanFunctionItem(RANfunction_Item_t *ranFuncItem, RanFunction *ranFuncDb)
{
- asn_enc_rval_t encRetVal;
- RanFunction *ranFuncDb;
+ uint8_t ret =RFAILED;
+ RANfunctionDefinition_t *ranFunctionDefinition;
RANfunction_Name_t *ranFuncName;
- uint8_t ranFuncIdx;
- RANfunction_ItemIEs_t *ranFuncItemIe;
- RANfunction_Item_t *ranFuncItem;
+ asn_enc_rval_t encRetVal;
E2SM_KPM_RANfunction_Description_t *ranFuncDefinition;
-
- ranFunctionsList->list.count = duCb.e2apDb.numOfRanFunction;
- ranFunctionsList->list.size = ranFunctionsList->list.count * sizeof(RANfunction_ItemIEs_t*);
- DU_ALLOC(ranFunctionsList->list.array, ranFunctionsList->list.size);
- if(ranFunctionsList->list.array == NULLP)
- {
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
- return RFAILED;
- }
-
- for(ranFuncIdx = 0; ranFuncIdx< ranFunctionsList->list.count; ranFuncIdx++)
+
+ while(true)
{
- DU_ALLOC(ranFunctionsList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
- if(ranFunctionsList->list.array[ranFuncIdx] == NULLP)
- {
- DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
- return RFAILED;
- }
-
- ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
- ranFuncItemIe->id = ProtocolIE_IDE2_id_RANfunction_Item;
- ranFuncItemIe->criticality = CriticalityE2_ignore;
- ranFuncItemIe->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item;
- ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
- ranFuncDb = &duCb.e2apDb.ranFunction[ranFuncIdx];
/* RAN function Id*/
ranFuncItem->ranFunctionID = ranFuncDb->id;
-
+
/* RAN Function Revision*/
ranFuncItem->ranFunctionRevision = ranFuncDb->revisionCounter;
-
+
/* RAN function OID*/
ranFuncItem->ranFunctionOID.size = strlen(ranFuncDb->name.serviceModelOID);
DU_ALLOC(ranFuncItem->ranFunctionOID.buf, ranFuncItem->ranFunctionOID.size);
if(!ranFuncItem->ranFunctionOID.buf)
{
DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
- return RFAILED;
+ break;
}
memcpy(ranFuncItem->ranFunctionOID.buf, ranFuncDb->name.serviceModelOID, ranFuncItem->ranFunctionOID.size);
if(!ranFuncDefinition)
{
DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
- return RFAILED;
+ break;
}
-
+
/* RAN function Name */
ranFuncName = &ranFuncDefinition->ranFunction_Name;
-
+
/* RAN function ShortName */
ranFuncName->ranFunction_ShortName.size = strlen(ranFuncDb->name.shortName);
DU_ALLOC(ranFuncName->ranFunction_ShortName.buf, ranFuncName->ranFunction_ShortName.size);
if(!ranFuncName->ranFunction_ShortName.buf)
{
DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
- return RFAILED;
+ break;
}
memcpy(ranFuncName->ranFunction_ShortName.buf, ranFuncDb->name.shortName, strlen(ranFuncDb->name.shortName));
-
+
/* RAN function E2SM_OID */
ranFuncName->ranFunction_E2SM_OID.size = strlen(ranFuncDb->name.serviceModelOID);
DU_ALLOC(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncName->ranFunction_E2SM_OID.size);
if(!ranFuncName->ranFunction_E2SM_OID.buf)
{
DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
- return RFAILED;
+ break;
}
memcpy(ranFuncName->ranFunction_E2SM_OID.buf, ranFuncDb->name.serviceModelOID, ranFuncName->ranFunction_E2SM_OID.size);
- /* RAN function Description */
+ /* RAN Function Name Description */
ranFuncName->ranFunction_Description.size = strlen(ranFuncDb->name.description);
DU_ALLOC(ranFuncName->ranFunction_Description.buf, ranFuncName->ranFunction_Description.size);
if(!ranFuncName->ranFunction_Description.buf)
{
DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
- return RFAILED;
+ break;
}
memcpy(ranFuncName->ranFunction_Description.buf, ranFuncDb->name.description, ranFuncName->ranFunction_Description.size);
-
+
/* RIC Event Trigger Style List */
DU_ALLOC(ranFuncDefinition->ric_EventTriggerStyle_List, sizeof(struct E2SM_KPM_RANfunction_Description__ric_EventTriggerStyle_List));
if(!ranFuncDefinition->ric_EventTriggerStyle_List)
{
DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
- return RFAILED;
+ break;
}
-
+
if(fillRicEventTriggerStyle(ranFuncDb, ranFuncDefinition->ric_EventTriggerStyle_List)!=ROK)
{
DU_LOG("\nERROR --> E2AP: failed to fill ric event trigger style");
- return RFAILED;
+ break;
}
/* RIC Report Style List */
if(!ranFuncDefinition->ric_ReportStyle_List)
{
DU_LOG("\nERROR --> E2AP: Memory allocation failed in function %s at %d",__func__,__LINE__);
- return RFAILED;
+ break;
}
if(fillRicReportStyle(ranFuncDb, ranFuncDefinition->ric_ReportStyle_List) != ROK)
{
DU_LOG("\nERROR --> E2AP: failed to fill ric report style");
- return RFAILED;
+ break;
}
/* Encode the F1SetupRequest type as APER */
{
printf("%x",encBuf[measIeIdx]);
}
-
+ ranFunctionDefinition = &ranFuncItem->ranFunctionDefinition;
+ ranFunctionDefinition->size = encBufSize;
+ DU_ALLOC(ranFunctionDefinition->buf, encBufSize);
+ if(ranFunctionDefinition->buf == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed for RAN function definition buffer");
+ break;
+ }
+ memcpy(ranFunctionDefinition->buf, &encBuf, encBufSize);
+ ret = ROK;
+ break;
}
- ranFuncItem->ranFunctionDefinition.size = encBufSize;
- DU_ALLOC(ranFuncItem->ranFunctionDefinition.buf, encBufSize);
- if(ranFuncItem->ranFunctionDefinition.buf == NULLP)
+ }
+ freeE2smKpmRanFunctionDefinition(ranFuncDefinition);
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds Ran function add list based on the procedure code
+ *
+ * @details
+ *
+ * Function : BuildRanFunctionAddList
+ *
+ * Functionality: Building RAN addition addition list
+ * In case of ProcedureCodeE2_id_E2setup we add all the RAN Function list
+ * which is present in E2 database.
+ * In the case of other procedures, we just fill the RAN functions whose ID
+ * is contained in recvList
+ *
+ * @params[in]
+ * RAN Function list
+ * Procedure code
+ * Count of ran functions to be added in the list
+ * Received list of RAN functions
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+
+uint8_t BuildRanFunctionAddList(RANfunctions_List_t *ranFunctionsList, uint8_t procedureCode, uint8_t count, RanFuncInfo *recvList)
+{
+ uint16_t id;
+ RanFunction *ranFuncDb;
+ uint8_t ranFuncIdx;
+ RANfunction_ItemIEs_t *ranFuncItemIe;
+
+ /* For ProcedureCodeE2_id_E2setup, the number of RAN function list items is
+ * equal to the number of ran function entries stored in the database.
+ * For any other procedure, the RAN function list count is equal
+ * to the count of ran functions obtained from the function's caller */
+
+ if(procedureCode == ProcedureCodeE2_id_E2setup)
+ ranFunctionsList->list.count = duCb.e2apDb.numOfRanFunction;
+ else
+ ranFunctionsList->list.count = count;
+
+ ranFunctionsList->list.size = ranFunctionsList->list.count * sizeof(RANfunction_ItemIEs_t*);
+ DU_ALLOC(ranFunctionsList->list.array, ranFunctionsList->list.size);
+ if(ranFunctionsList->list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
+ return RFAILED;
+ }
+
+ for(ranFuncIdx = 0; ranFuncIdx< ranFunctionsList->list.count; ranFuncIdx++)
+ {
+ DU_ALLOC(ranFunctionsList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
+ if(ranFunctionsList->list.array[ranFuncIdx] == NULLP)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed for RAN function definition buffer");
+ DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
return RFAILED;
}
- memcpy(ranFuncItem->ranFunctionDefinition.buf, &encBuf, encBufSize);
+ if(procedureCode == ProcedureCodeE2_id_E2setup)
+ {
+ /* Getting all of the RAN function's information from DuCb one by one*/
+ ranFuncDb = &duCb.e2apDb.ranFunction[ranFuncIdx];
+ }
+ else
+ {
+ /* Getting only the RAN function information from DuCb whose Id is
+ * present in the received array */
+ id =recvList[ranFuncIdx].id;
+ ranFuncDb = &duCb.e2apDb.ranFunction[id-1];
+ }
+ ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
+ ranFuncItemIe->id = ProtocolIE_IDE2_id_RANfunction_Item;
+ ranFuncItemIe->criticality = CriticalityE2_ignore;
+ ranFuncItemIe->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item;
+ BuildRanFunctionItem(&ranFuncItemIe->value.choice.RANfunction_Item, ranFuncDb);
}
- freeE2smKpmRanFunctionDefinition(ranFuncDefinition);
return ROK;
-}
+}
/*******************************************************************
*
e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded;
e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_RANfunctions_List;
- if(BuildRanFunctionAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List))!=ROK)
+ if(BuildRanFunctionAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List), ProcedureCodeE2_id_E2setup, 0, NULL)!=ROK)
{
DU_LOG("\nERROR --> E2AP : Failed to create RAN Function");
break;
break;
}while(true);
- duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].transactionId = transId;
- duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
+ duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
+ duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
FreeE2SetupReq(e2apMsg);
return ret;
case ProtocolIE_IDE2_id_TransactionID:
{
transId = e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
- if((duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].transactionId == transId) &&\
- (duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
- memset(&duCb.e2apDb.e2TransInfo.onGoingTransaction[transId], 0, sizeof(E2TransInfo));
+ if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
+ (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
+ {
+ memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
+ }
else
{
DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
free(ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.\
list.array);
+#ifdef KPI_CALCULATION
/* This is a dummy trigger for statistics request. It will
* be removed in next gerrit and actual statistics request
* will be sent when RIC subscription request is received
* from RIC */
ricSubscriptionInfo->actionSequence[0].definition.styleType = 1;
BuildAndSendStatsReq(ricSubscriptionInfo->actionSequence[0].definition);
+#endif
}
break;
}
/* In case the message is sent successfully, store the transaction info to
* be used when response is received */
- duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].transactionId = transId;
- duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
+ duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
+ duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
ret = ROK;
break;
{
case ProtocolIE_IDE2_id_TransactionID:
transId = resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
- if((duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].transactionId == transId) && \
- (duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
- memset(&duCb.e2apDb.e2TransInfo.onGoingTransaction[transId], 0, sizeof(E2TransInfo));
+ if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) && \
+ (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
+ {
+ memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
+ }
else
{
DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
case ProtocolIE_IDE2_id_TransactionID:
{
transId = e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
- if((duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].transactionId == transId) &&\
- (duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
- memset(&duCb.e2apDb.e2TransInfo.onGoingTransaction[transId], 0, sizeof(E2TransInfo));
+ if((duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId == transId) &&\
+ (duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
+ {
+ memset(&duCb.e2apDb.e2TransInfo.e2InitTransaction[transId], 0, sizeof(E2TransInfo));
+ }
else
{
DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
case ProtocolIE_IDE2_id_TimeToWaitE2:
{
timerValue = covertE2WaitTimerEnumToValue(e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
- if((duChkTmr((PTR)&(duCb.e2apDb), EVENT_E2_SETUP_TMR)) == FALSE)
+ if((duChkTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR)) == FALSE)
{
- duStartTmr((PTR)&(duCb.e2apDb), EVENT_E2_SETUP_TMR, timerValue);
+ duStartTmr((PTR)&(duCb.e2apDb.e2TimersInfo.e2Timers.e2SetupTimer), EVENT_E2_SETUP_TMR, timerValue);
}
else
{
freeAperDecodingOfE2SetupFailure(e2SetupFailure);
}
+/******************************************************************
+ *
+ * @brief Deallocation of memory allocated bu aper decoder for RIC service Query
+ *
+ * @details
+ *
+ * Function : freeAperDecodingOfRicServiceQuery
+ *
+ * Functionality: Deallocation of memory allocated bu aper decoder for RIC
+ * service Query
+ *
+ * @params[in] RICserviceQuery_t *ricServiceQuery;
+ * @return void
+ *
+ * ****************************************************************/
+
+void freeAperDecodingOfRicServiceQuery(RICserviceQuery_t *ricServiceQuery)
+{
+ uint8_t arrIdx,ranFuncIdx;
+ RANfunctionsID_List_t *ranFuncAddedList;
+
+ if(ricServiceQuery)
+ {
+ if(ricServiceQuery->protocolIEs.list.array)
+ {
+ for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
+ {
+ if(ricServiceQuery->protocolIEs.list.array[arrIdx])
+ {
+ switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
+ {
+ case ProtocolIE_IDE2_id_RANfunctionsAccepted:
+ {
+ ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
+ if(ranFuncAddedList->list.array)
+ {
+ for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
+ {
+ free(ranFuncAddedList->list.array[ranFuncIdx]);
+ }
+ free(ranFuncAddedList->list.array);;
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ free(ricServiceQuery->protocolIEs.list.array[arrIdx]);
+ }
+ }
+ free(ricServiceQuery->protocolIEs.list.array);
+ }
+ }
+}
+/*******************************************************************
+ *
+ * @brief Build RanFunction Delete List
+ *
+ * @details
+ *
+ * Function : BuildRanFunctionDeleteList
+ *
+ * Functionality: Build RanFunction Delete List
+ *
+ * @params[in]
+ * RANfunctionsID List
+ * Count of the RAN function
+ * Received RAN function list
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+
+uint8_t BuildRanFunctionDeleteList(RANfunctionsID_List_t *deleteList, uint8_t count, RanFuncInfo *recvdRanFunc)
+{
+ uint8_t ranFuncIdx=0;
+ RANfunctionID_ItemIEs_t *delRanFuncItem;
+
+ if(count)
+ {
+ deleteList->list.count = count;
+ deleteList->list.size = deleteList->list.count * sizeof(RANfunctionID_ItemIEs_t*);
+ DU_ALLOC(deleteList->list.array, deleteList->list.size);
+ if(deleteList->list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
+ return RFAILED;
+ }
+ for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++)
+ {
+ DU_ALLOC(deleteList->list.array[ranFuncIdx], sizeof(RANfunctionID_ItemIEs_t));
+ if(deleteList->list.array[ranFuncIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP: Memory allocation failed in %s at %d",__func__, __LINE__);
+ return RFAILED;
+ }
+ delRanFuncItem= (RANfunctionID_ItemIEs_t *) deleteList->list.array[ranFuncIdx];
+ delRanFuncItem->id = ProtocolIE_IDE2_id_RANfunctionID_Item;
+ delRanFuncItem->criticality = CriticalityE2_ignore;
+ delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionID = recvdRanFunc[ranFuncIdx].id;
+ delRanFuncItem->value.choice.RANfunctionID_Item.ranFunctionRevision = recvdRanFunc[ranFuncIdx].revisionCounter;
+
+ }
+ }
+ return ROK;
+}
+/*******************************************************************
+ *
+ * @brief De Allocate Ric Service Update message
+ *
+ * @details
+ *
+ * Function : FreeRicServiceUpdate
+ *
+ * Functionality: De-Allocating Ric Service Update message
+ *
+ * @params[in] E2AP_PDU_t *e2apMsg
+
+ * @return void
+ *
+ * ****************************************************************/
+
+void FreeRicServiceUpdate(E2AP_PDU_t *e2apMsg)
+{
+ uint8_t arrIdx = 0;
+ uint8_t ranFuncAddListIdx=0, ranFuncDelIdx=0;
+ RICserviceUpdate_t *ricServiceUpdate;
+ RANfunctions_List_t *ranFunctionsList;
+ RANfunction_ItemIEs_t *ranFuncItemIe;
+ RANfunction_Item_t *ranFunItem;
+ RANfunctionsID_List_t *deleteList;
+
+ /* De-allocating Memory */
+ if(e2apMsg != NULLP)
+ {
+ if(e2apMsg->choice.initiatingMessage != NULLP)
+ {
+ ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate;
+ if(ricServiceUpdate->protocolIEs.list.array != NULLP)
+ {
+ for(arrIdx = 0; arrIdx < ricServiceUpdate->protocolIEs.list.count; arrIdx++)
+ {
+ if(ricServiceUpdate->protocolIEs.list.array[arrIdx] != NULLP)
+ {
+ switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id)
+ {
+ case ProtocolIE_IDE2_id_TransactionID:
+ break;
+
+ case ProtocolIE_IDE2_id_RANfunctionsAdded:
+ case ProtocolIE_IDE2_id_RANfunctionsModified:
+ {
+ ranFunctionsList = &(ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List);
+ if(ranFunctionsList->list.array)
+ {
+ for(ranFuncAddListIdx= 0; ranFuncAddListIdx< ranFunctionsList->list.count; ranFuncAddListIdx++)
+ {
+ if(ranFunctionsList->list.array[ranFuncAddListIdx])
+ {
+ ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncAddListIdx];
+ ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
+ DU_FREE(ranFunItem->ranFunctionOID.buf, ranFunItem->ranFunctionOID.size);
+ DU_FREE(ranFunItem->ranFunctionDefinition.buf, ranFunItem->ranFunctionDefinition.size);
+ DU_FREE(ranFunctionsList->list.array[ranFuncAddListIdx], sizeof(RANfunction_ItemIEs_t));
+ }
+ }
+ DU_FREE(ranFunctionsList->list.array, ranFunctionsList->list.size);
+ }
+ break;
+ }
+ case ProtocolIE_IDE2_id_RANfunctionsDeleted:
+ {
+ deleteList= &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
+ if(deleteList->list.array)
+ {
+ for(ranFuncDelIdx = 0; ranFuncDelIdx< deleteList->list.count; ranFuncDelIdx++)
+ {
+ DU_FREE(deleteList->list.array[ranFuncDelIdx], sizeof(RANfunctionID_ItemIEs_t));
+ }
+ DU_FREE(deleteList->list.array, deleteList->list.size);
+
+ }
+ break;
+ }
+ default:
+ DU_LOG("\nERROR --> E2AP: Invalid event at ricServiceUpdate %ld ",\
+ (ricServiceUpdate->protocolIEs.list.array[arrIdx]->id));
+ break;
+ }
+ DU_FREE(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t));
+ }
+ }
+ DU_FREE(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
+ }
+ DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
+ }
+ DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Builds and Send the RicServiceUpdateuest
+ *
+ * @details
+ *
+ * Function : BuildAndSendRicServiceUpdate
+ *
+ * Functionality:Fills the RicServiceUpdateuest
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+
+uint8_t BuildAndSendRicServiceUpdate(RicServiceUpdate serviceUpdate)
+{
+ uint8_t arrIdx = 0, elementCnt=0;
+ uint8_t transId = 0, ret = RFAILED;
+ bool memAllocFailed =false;
+ E2AP_PDU_t *e2apMsg = NULLP;
+ RICserviceUpdate_t *ricServiceUpdate = NULLP;
+ asn_enc_rval_t encRetVal; /* Encoder return value */
+
+ DU_LOG("\nINFO --> E2AP : Building Ric Service Update\n");
+ do
+ {
+ DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
+ if(e2apMsg == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ break;
+ }
+ e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
+ DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
+ if(e2apMsg->choice.initiatingMessage == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
+ break;
+ }
+ e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
+ e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
+ e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceUpdate;
+ ricServiceUpdate = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate;
+
+ /* For TransId IE, set elementCnt to 1.
+ If there is any item in the RAN function add list, RAN function modification list, or RAN function delete list, increment the elementCnt.*/
+
+ elementCnt =1;
+ if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
+ elementCnt++;
+ if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified)
+ elementCnt++;
+ if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted)
+ elementCnt++;
+
+ ricServiceUpdate->protocolIEs.list.count = elementCnt;
+ ricServiceUpdate->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdate_IEs_t*);
+
+ /* Initialize the E2Setup members */
+ DU_ALLOC(ricServiceUpdate->protocolIEs.list.array, ricServiceUpdate->protocolIEs.list.size);
+ if(ricServiceUpdate->protocolIEs.list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
+ break;
+ }
+
+ for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
+ {
+ DU_ALLOC(ricServiceUpdate->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdate_IEs_t));
+ if(ricServiceUpdate->protocolIEs.list.array[arrIdx] == NULLP)
+ {
+ memAllocFailed = true;
+ DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayIdx [%d]", arrIdx);
+ break;
+ }
+ }
+ if(memAllocFailed == true)
+ break;
+
+ arrIdx = 0;
+
+ /* TransactionID */
+ ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
+ ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
+ ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
+ if(serviceUpdate.dir == E2_NODE_INITIATED)
+ transId = assignTransactionId();
+ else
+ transId = serviceUpdate.transId;
+ ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
+
+ if(serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded)
+ {
+ arrIdx++;
+ ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAdded;
+ ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
+ ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
+ if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,\
+ e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeAdded, serviceUpdate.recvRanFuncList.ranFunToBeAdded) !=ROK)
+ {
+ break;
+ }
+ }
+
+ if(serviceUpdate.recvRanFuncList.numOfRanFunToBeModified)
+ {
+ arrIdx++;
+ ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsModified;
+ ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
+ ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctions_List;
+ if(BuildRanFunctionAddList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List,
+ e2apMsg->choice.initiatingMessage->procedureCode, serviceUpdate.recvRanFuncList.numOfRanFunToBeModified, serviceUpdate.recvRanFuncList.ranFunToBeModified) !=ROK)
+ {
+ break;
+ }
+ }
+
+ if(serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted)
+ {
+ arrIdx++;
+ ricServiceUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsDeleted;
+ ricServiceUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
+ ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdate_IEs__value_PR_RANfunctionsID_List;
+ if(BuildRanFunctionDeleteList(&ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List,\
+ serviceUpdate.recvRanFuncList.numOfRanFunToBeDeleted, serviceUpdate.recvRanFuncList.ranFunToBeDeleted) != ROK)
+ {
+ break;
+ }
+ }
+ /* Prints the Msg formed */
+ xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
+
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG("\nERROR --> E2AP : Could not encode RicServiceUpdateuest structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicServiceUpdateuest\n");
+#ifdef DEBUG_ASN_PRINT
+ for(int i=0; i< encBufSize; i++)
+ {
+ printf("%x",encBuf[i]);
+ }
+#endif
+ }
+ if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
+ break;
+ }
+ ret = ROK;
+ break;
+ }while(true);
+
+ if(ret == ROK)
+ {
+ if(serviceUpdate.dir == E2_NODE_INITIATED)
+ {
+ duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].transactionId = transId;
+ duCb.e2apDb.e2TransInfo.e2InitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
+ }
+ else
+ {
+ duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].transactionId = transId;
+ duCb.e2apDb.e2TransInfo.ricInitTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
+ }
+ duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.dir = serviceUpdate.dir;
+ duCb.e2apDb.e2TimersInfo.e2Timers.ricServiceUpdateTimer.ricService.transId =transId;
+ }
+ FreeRicServiceUpdate(e2apMsg);
+ return ret;
+}
+/******************************************************************
+ *
+ * @brief Processes RIC service Query sent by RIC
+ *
+ * @details
+ *
+ * Function : procRicServiceQuery
+ *
+ * Functionality: Processes RIC service Query sent by RIC
+ *
+ * @params[in] E2AP_PDU_t ASN decoded E2AP message
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+void procRicServiceQuery(E2AP_PDU_t *e2apMsg)
+{
+ ConfigType action;
+ uint8_t arrIdx =0, ranFuncIdx=0,tmpIdx=0;
+ uint16_t id,revisionCcounter;
+ bool tmpArray[MAX_RAN_FUNCTION] = {false};
+ RICserviceQuery_t *ricServiceQuery=NULL;
+ RicServiceUpdate ricUpdate;
+ RANfunctionID_ItemIEs_t *ranFuncAddedItemIe;
+ RANfunctionsID_List_t *ranFuncAddedList;
+
+ DU_LOG("\nINFO --> E2AP : RIC Service Query received");
+ memset(&ricUpdate, 0, sizeof(RicServiceUpdate));
+ ricUpdate.dir = RIC_INITIATED;
+ ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
+
+ for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
+ {
+ switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
+ {
+ /* TODO completing in next patch/gerrit */
+ case ProtocolIE_IDE2_id_TransactionID:
+ {
+ ricUpdate.transId = ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
+ break;
+ }
+
+ case ProtocolIE_IDE2_id_RANfunctionsAccepted:
+ {
+ ranFuncAddedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
+ if(ranFuncAddedList->list.array)
+ {
+ for(ranFuncIdx=0;ranFuncIdx<ranFuncAddedList->list.count; ranFuncIdx++)
+ {
+ if(ranFuncAddedList->list.array[ranFuncIdx])
+ {
+ /* Using the RAN function Id, identify the RAN function to be modified or deleted. */
+
+ ranFuncAddedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAddedList->list.array[ranFuncIdx];
+ id = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionID;
+ revisionCcounter = ranFuncAddedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision;
+
+ if((id != duCb.e2apDb.ranFunction[id-1].id))
+ {
+ action = CONFIG_DEL;
+ }
+ else if((id == duCb.e2apDb.ranFunction[id-1].id)&&(revisionCcounter!=duCb.e2apDb.ranFunction[id-1].revisionCounter))
+ {
+ action = CONFIG_MOD;
+ }
+
+ if(action == CONFIG_DEL)
+ {
+ ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].id = id;
+ ricUpdate.recvRanFuncList.ranFunToBeDeleted[ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted].revisionCounter = revisionCcounter;
+ ricUpdate.recvRanFuncList.numOfRanFunToBeDeleted++;
+ }
+ else if(action == CONFIG_MOD)
+ {
+ ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].id = id;
+ ricUpdate.recvRanFuncList.ranFunToBeModified[ricUpdate.recvRanFuncList.numOfRanFunToBeModified].revisionCounter = revisionCcounter;
+ ricUpdate.recvRanFuncList.numOfRanFunToBeModified++;
+ }
+
+ /* If any ID is set to true, it means that the ID has been used in either modification or deletion list.
+ * Else we will add the IDs into the added list */
+ tmpArray[id-1] = true;
+ }
+ }
+ }
+ break;
+ }
+ }
+ }
+
+ /* Traversing the whole RAN function list in ducb to check if any new Ran function ids have been added. */
+ for(arrIdx =0; arrIdx<MAX_RAN_FUNCTION; arrIdx++)
+ {
+ tmpIdx= ricUpdate.recvRanFuncList.numOfRanFunToBeAdded;
+ if((duCb.e2apDb.ranFunction[arrIdx].id >0)&&(!tmpArray[arrIdx]))
+ {
+ ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].id = duCb.e2apDb.ranFunction[arrIdx].id;
+ ricUpdate.recvRanFuncList.ranFunToBeAdded[tmpIdx].revisionCounter = duCb.e2apDb.ranFunction[arrIdx].revisionCounter;
+ ricUpdate.recvRanFuncList.numOfRanFunToBeAdded++;
+ }
+ }
+ if(BuildAndSendRicServiceUpdate(ricUpdate)!= ROK)
+ {
+ DU_LOG("\nERROR --> E2AP : Failed to build and send ric service update message");
+ }
+
+ freeAperDecodingOfRicServiceQuery(ricServiceQuery);
+}
+
+
/*******************************************************************
*
* @brief Handles received E2AP message and sends back response
procRicSubsReq(e2apMsg);
break;
}
+ case InitiatingMessageE2__value_PR_RICserviceQuery:
+ {
+ procRicServiceQuery(e2apMsg);
+ break;
+ }
default:
{
DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\