From: lal.harshita Date: Fri, 22 Sep 2023 16:02:46 +0000 (+0530) Subject: [Epic-ID: ODUHIGH-516][Task-ID: ODUHIGH-528] RIC Subscription Response X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=commitdiff_plain;h=bd928523f61aead825b448daee545b8455e8daee;p=o-du%2Fl2.git [Epic-ID: ODUHIGH-516][Task-ID: ODUHIGH-528] RIC Subscription Response Change-Id: I88abc6d30a8280b8f534fd8e16efdb0e41ee0e5b Signed-off-by: lal.harshita --- diff --git a/src/du_app/du_e2ap_mgr.h b/src/du_app/du_e2ap_mgr.h index 1cdb2f410..935e9a03e 100644 --- a/src/du_app/du_e2ap_mgr.h +++ b/src/du_app/du_e2ap_mgr.h @@ -32,6 +32,7 @@ #define MAX_LABEL_INFO 2147483648 /* O-RAN.WG3.E2SM-KPM-R003-v03.00 : Section 8.2.1.2.1 : maxnoofLabelInfo */ #define MAX_RIC_ACTION 16 /* O-RAN.WG3.E2AP-R003-v03.00 : Section 9.1.1.1 : maxofRICActionID */ #define MAX_RIC_REQUEST 65535 /* O-RAN.WG3.E2AP-R003-v03.00 : Section 9.2.7 */ +#define MAX_PENDING_SUBSCRIPTION_RSP 5 /* Number of statistics request in processing */ #define STRING_SIZE_150_BYTES 150 #define STRING_SIZE_1000_BYTES 1000 @@ -165,6 +166,12 @@ typedef enum typedef uint8_t E2Cause; +typedef struct e2FailureCause +{ + E2CauseType causeType; + uint8_t cause; +}E2FailureCause; + typedef struct { uint8_t transactionId; @@ -359,6 +366,22 @@ typedef struct ActionInfo actionSequence[MAX_RIC_ACTION]; }RicSubscription; +typedef struct rejectedAction +{ + uint8_t id; + E2FailureCause failureCause; +}RejectedAction; + +typedef struct pendingSubsRspInfo +{ + RicRequestId requestId; + uint16_t ranFuncId; + uint8_t numOfAcceptedActions; + uint8_t acceptedActionList[MAX_RIC_ACTION]; + uint8_t numOfRejectedActions; + RejectedAction rejectedActionList[MAX_RIC_ACTION]; +}PendingSubsRspInfo; + typedef struct { /* O-RAN.WG3.E2SM-KPM-R003-v03.00 : Section 8.2.2.1 */ @@ -373,6 +396,8 @@ typedef struct uint8_t ricIndicationMessageFormat; /* O-RAN.WG3.E2AP-R003-v03.00 : Section 9.1.1.1 */ CmLListCp subscriptionList; + uint8_t numPendingSubsRsp; + PendingSubsRspInfo pendingSubsRspInfo[MAX_PENDING_SUBSCRIPTION_RSP]; }RanFunction; /* O-RAN.WG3.E2AP-R003-v03.00 : Section 9.2.26-9.2.27 */ @@ -423,12 +448,6 @@ typedef struct E2TimersInfo e2TimersInfo; }E2apDb; -typedef struct e2FailureCause -{ - E2CauseType causeType; - uint8_t cause; -}E2FailureCause; - uint8_t assignTransactionId(); uint8_t ResetE2Request(E2ProcedureDirection dir, E2FailureCause resetCause); uint8_t SendE2APMsg(Region region, Pool pool, char *encBuf, int encBufSize); diff --git a/src/du_app/du_e2ap_msg_hdl.c b/src/du_app/du_e2ap_msg_hdl.c index ac86380ee..a8ea182a3 100644 --- a/src/du_app/du_e2ap_msg_hdl.c +++ b/src/du_app/du_e2ap_msg_hdl.c @@ -1156,121 +1156,111 @@ uint8_t BuildAndSendE2SetupReq() /******************************************************************* * - * @brief Builds Ric Request Id + * @brief Builds RIC Action Admitted List * * @details * - * Function : BuildRicRequestId + * Function : BuildRicActionAdmitList * - * Functionality: Building the Ric Request Id + * Functionality: Builds RIC Action Admitted List * - * @params[in] RICrequestID_t *ricReqId + * @params[in] Pointer to RIC Action Admitted List to be filled + * Subscription Response information * @return ROK - success * RFAILED - failure * * ****************************************************************/ - -uint8_t BuildRicRequestId(RICrequestID_t *ricReqId) +uint8_t BuildRicActionAdmitList(RICaction_Admitted_List_t *admitList, PendingSubsRspInfo *subsRspInfo) { - if(ricReqId == NULLP) - { - return RFAILED; - } - - ricReqId->ricRequestorID = 1; - ricReqId->ricInstanceID = 1; - return ROK; -} + uint8_t idx = 0; + uint8_t elementCnt = 0; + RICaction_Admitted_ItemIEs_t *admitItem = NULLP; -/******************************************************************* - * - * @brief Fills the mandatory RicAdmitted List Items - * - * @details - * - * Function : fillRicAdmitList - * - * Functionality: Fills the mandatory Ric Admitted List Items - * - * @params[in] RICaction_Admitted_ItemIEs_t *ricAdmitItems - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ + elementCnt = subsRspInfo->numOfAcceptedActions; -uint8_t fillRicAdmitList(RICaction_Admitted_ItemIEs_t *ricAdmitItems) -{ + admitList->list.count = elementCnt; + admitList->list.size = elementCnt * sizeof(RICaction_Admitted_ItemIEs_t *); - if(ricAdmitItems != NULLP) + DU_ALLOC(admitList->list.array, admitList->list.size); + if(admitList->list.array == NULLP) { - ricAdmitItems->id = ProtocolIE_IDE2_id_RICaction_Admitted_Item; - ricAdmitItems->criticality = CriticalityE2_reject; - ricAdmitItems->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item; - ricAdmitItems->value.choice.RICaction_Admitted_Item.ricActionID = 1; + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; } - else + + for(idx=0; idxlist.array[idx], sizeof(RICaction_Admitted_ItemIEs_t)); + if(admitList->list.array[idx] == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; + } + + admitItem = (RICaction_Admitted_ItemIEs_t *)admitList->list.array[idx]; + admitItem->id = ProtocolIE_IDE2_id_RICaction_Admitted_Item; + admitItem->criticality = CriticalityE2_reject; + admitItem->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item; + admitItem->value.choice.RICaction_Admitted_Item.ricActionID = subsRspInfo->acceptedActionList[idx]; } return ROK; } + /******************************************************************* * - * @brief Builds the mandatory RicAdmitted List Params + * @brief Builds RIC Action Not Admitted List * * @details * - * Function : BuildRicAdmitList + * Function : BuildRicActionNotAdmitList * - * Functionality: Builds the mandatory Ric Admitted List Params + * Functionality: Builds RIC Action Not Admitted List * - * @params[in] RICaction_Admitted_List_t *admitListPtr + * @params[in] Pointer to RIC Action Not Admitted List to be filled + * Subscription Response information * @return ROK - success * RFAILED - failure * * ****************************************************************/ - -uint8_t BuildRicAdmitList(RICaction_Admitted_List_t *admitListPtr) +uint8_t BuildRicActionNotAdmitList(RICaction_NotAdmitted_List_t *notAdmitList, PendingSubsRspInfo *subsRspInfo) { - uint8_t idx ; - uint8_t elementCnt; - uint8_t ret= ROK; - elementCnt = 1; + uint8_t idx = 0; + uint8_t elementCnt = 0; + RICaction_NotAdmitted_ItemIEs_t *notAdmitItem = NULLP; + + elementCnt = subsRspInfo->numOfRejectedActions; + + notAdmitList->list.count = elementCnt; + notAdmitList->list.size = elementCnt * sizeof(RICaction_NotAdmitted_ItemIEs_t *); - if(admitListPtr == NULLP) + DU_ALLOC(notAdmitList->list.array, notAdmitList->list.size); + if(notAdmitList->list.array == NULLP) { - DU_LOG("\nERROR --> E2AP : Memory allocation for RIC Admit List failed"); - ret = RFAILED; + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; } - else + + for(idx=0; idxlist.count = elementCnt; - admitListPtr->list.size = elementCnt * sizeof(RICaction_Admitted_ItemIEs_t); - DU_ALLOC(admitListPtr->list.array, admitListPtr->list.size); - if(admitListPtr->list.array == NULLP) + DU_ALLOC(notAdmitList->list.array[idx], sizeof(RICaction_NotAdmitted_ItemIEs_t)); + if(notAdmitList->list.array[idx] == NULLP) { - DU_LOG("\nERROR --> E2AP : Memory allocation for RIC Admit List failed"); - ret = RFAILED; - } - else - { - for(idx=0 ; idxlist.array[idx], sizeof(RICaction_Admitted_ItemIEs_t)); - if(admitListPtr->list.array[idx] == NULLP) - { - ret = RFAILED; - } - } - if(ret != RFAILED) - { - idx=0; - fillRicAdmitList((RICaction_Admitted_ItemIEs_t *)admitListPtr->list.array[idx]); - } + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d]", __func__, __LINE__); + return RFAILED; } - } - return ret; + + notAdmitItem = (RICaction_NotAdmitted_ItemIEs_t *)notAdmitList->list.array[idx]; + notAdmitItem->id = ProtocolIE_IDE2_id_RICaction_NotAdmitted_Item; + notAdmitItem->criticality = CriticalityE2_reject; + notAdmitItem->value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item; + notAdmitItem->value.choice.RICaction_NotAdmitted_Item.ricActionID = \ + subsRspInfo->rejectedActionList[idx].id; + fillE2Cause(¬AdmitItem->value.choice.RICaction_NotAdmitted_Item.cause, \ + subsRspInfo->rejectedActionList[idx].failureCause); + } + return ROK; } + /******************************************************************* * * @breif Deallocation of BuildAndSendRicSubscriptionRsp memory @@ -1285,152 +1275,166 @@ uint8_t BuildRicAdmitList(RICaction_Admitted_List_t *admitListPtr) * * @return void * - * ******************************************************************/ void FreeRicSubscriptionRsp(E2AP_PDU_t *e2apRicMsg) { RICsubscriptionResponse_t *ricSubscriptionRsp= NULLP; uint8_t idx=0; - uint8_t idx1=0; - RICaction_Admitted_List_t *admitListPtr; + uint8_t listIdx=0; + RICaction_Admitted_List_t *admitList = NULLP; + RICaction_NotAdmitted_List_t *notAdmitList = NULLP; if(e2apRicMsg != NULLP) { if(e2apRicMsg->choice.successfulOutcome != NULLP) { - ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse; - if(ricSubscriptionRsp) - { - if(ricSubscriptionRsp->protocolIEs.list.array != NULLP) - { - for(idx=0; idxprotocolIEs.list.count; idx++) - { - if(ricSubscriptionRsp->protocolIEs.list.array[idx] != NULLP) - { - switch(ricSubscriptionRsp->protocolIEs.list.array[idx]->id) - { - case ProtocolIE_IDE2_id_RICrequestID: - break; - - case ProtocolIE_IDE2_id_RANfunctionID: - break; - - case ProtocolIE_IDE2_id_RICactions_Admitted: - { - admitListPtr = &ricSubscriptionRsp->protocolIEs.list.\ - array[idx]->value.choice.RICaction_Admitted_List; - if(admitListPtr->list.array != NULLP) - { - for(idx1=0 ; idx1list.count; idx1++ ) - { - if(admitListPtr->list.array[idx1] != NULLP) - { - DU_FREE(admitListPtr->list.array[idx1], - sizeof(RICaction_Admitted_ItemIEs_t)); - } - } - DU_FREE(admitListPtr->list.array, admitListPtr->list.size); - } - break; - } - default: - break; - } - DU_FREE(ricSubscriptionRsp->protocolIEs.list.array[idx], \ - sizeof(RICsubscriptionResponse_IEs_t)); - } - } - DU_FREE(ricSubscriptionRsp->protocolIEs.list.array, \ - ricSubscriptionRsp->protocolIEs.list.size); - } - } - DU_FREE(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t)); + ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse; + if(ricSubscriptionRsp) + { + if(ricSubscriptionRsp->protocolIEs.list.array != NULLP) + { + for(idx=0; idxprotocolIEs.list.count; idx++) + { + if(ricSubscriptionRsp->protocolIEs.list.array[idx] != NULLP) + { + switch(ricSubscriptionRsp->protocolIEs.list.array[idx]->id) + { + case ProtocolIE_IDE2_id_RICactions_Admitted: + { + admitList = &ricSubscriptionRsp->protocolIEs.list.\ + array[idx]->value.choice.RICaction_Admitted_List; + if(admitList->list.array != NULLP) + { + for(listIdx=0 ; listIdx < admitList->list.count; listIdx++) + { + DU_FREE(admitList->list.array[listIdx], sizeof(RICaction_Admitted_ItemIEs_t)); + } + DU_FREE(admitList->list.array, admitList->list.size); + } + break; + } + case ProtocolIE_IDE2_id_RICactions_NotAdmitted: + { + notAdmitList = &ricSubscriptionRsp->protocolIEs.list.\ + array[idx]->value.choice.RICaction_NotAdmitted_List; + if(notAdmitList->list.array != NULLP) + { + for(listIdx=0 ; listIdx < notAdmitList->list.count; listIdx++) + { + DU_FREE(notAdmitList->list.array[listIdx], sizeof(RICaction_NotAdmitted_ItemIEs_t)); + } + DU_FREE(notAdmitList->list.array, notAdmitList->list.size); + } + break; + } + default: + break; + } + DU_FREE(ricSubscriptionRsp->protocolIEs.list.array[idx], sizeof(RICsubscriptionResponse_IEs_t)); + } + } + DU_FREE(ricSubscriptionRsp->protocolIEs.list.array, ricSubscriptionRsp->protocolIEs.list.size); + } + } + DU_FREE(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t)); } DU_FREE(e2apRicMsg, sizeof(E2AP_PDU_t)); } } + /******************************************************************* * - * @brief Builds and Send the RicSubscriptionRsp + * @brief Fill RIC Subscription Response IEs * * @details * - * Function : BuildAndSendRicSubscriptionRsp + * Function : fillRicSubscriptionRsp * - * functionality:Fills the RicSubscriptionRsp + * functionality: Fill RIC Subscription Response IEs * + * @param Pointer to RIC subscription response + * Subscription response information * @return ROK - success * RFAILED - failure * ******************************************************************/ -uint8_t FillRicSubscriptionRsp(RICsubscriptionResponse_t *ricSubscriptionRsp ) +uint8_t fillRicSubscriptionRsp(RICsubscriptionResponse_t *ricSubscriptionRsp, PendingSubsRspInfo *subsRspInfo) { - uint8_t idx=0; - uint8_t ret = ROK; + uint8_t ieIdx = 0; uint8_t elementCnt = 0; - uint8_t BuildRicRequestIdret=ROK; - uint8_t BuildRicAdmitListret=ROK; + RICsubscriptionResponse_IEs_t *subsRspIe = NULLP; + + elementCnt = 3; + if(subsRspInfo->numOfRejectedActions) + elementCnt++; - elementCnt=3; ricSubscriptionRsp->protocolIEs.list.count = elementCnt; ricSubscriptionRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionResponse_IEs_t); - DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array, \ - ricSubscriptionRsp->protocolIEs.list.size); + DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array, ricSubscriptionRsp->protocolIEs.list.size); if(ricSubscriptionRsp->protocolIEs.list.array == NULLP) { - DU_LOG("\nERROR --> E2AP : Memory allocation for FillRicSubscriptionRsp failed"); - ret = RFAILED; + DU_LOG("\nERROR --> E2AP : Memory allocation failed at %s : line %d", __func__, __LINE__); + return RFAILED; } - else + + for(ieIdx=0; ieIdxprotocolIEs.list.count; ieIdx++) { - for(idx=0; idxprotocolIEs.list.count; idx++) + DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array[ieIdx], sizeof(RICsubscriptionResponse_IEs_t)); + if(ricSubscriptionRsp->protocolIEs.list.array[ieIdx] == NULLP) { - DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array[idx], \ - sizeof(RICsubscriptionResponse_IEs_t)); - if(ricSubscriptionRsp->protocolIEs.list.array[idx] == NULLP) - { - ret = RFAILED; - } + DU_LOG("\nERROR --> E2AP : Memory allocation failed at [%s] : line [%d] : ieIdx [%d]", __func__, __LINE__,ieIdx); + return RFAILED; } - if(ret != RFAILED) - { + } - idx=0; - ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID; - ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; - ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\ - RICsubscriptionRequest_IEs__value_PR_RICrequestID; - BuildRicRequestIdret = - BuildRicRequestId(&ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RICrequestID); - if(BuildRicRequestIdret != ROK) - { - ret = RFAILED; - } - else - { - idx++; - ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID; - ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; - ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\ - RICsubscriptionRequest_IEs__value_PR_RANfunctionID; - ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionID = 1; + /* RIC Request ID */ + ieIdx=0; + subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx]; + subsRspIe->id = ProtocolIE_IDE2_id_RICrequestID; + subsRspIe->criticality = CriticalityE2_reject; + subsRspIe->value.present = RICsubscriptionRequest_IEs__value_PR_RICrequestID; + subsRspIe->value.choice.RICrequestID.ricRequestorID = subsRspInfo->requestId.requestorId; + subsRspIe->value.choice.RICrequestID.ricInstanceID = subsRspInfo->requestId.instanceId; + + /* RAN Function ID */ + ieIdx++; + subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx]; + subsRspIe->id = ProtocolIE_IDE2_id_RANfunctionID; + subsRspIe->criticality = CriticalityE2_reject; + subsRspIe->value.present = RICsubscriptionRequest_IEs__value_PR_RANfunctionID; + subsRspIe->value.choice.RANfunctionID = subsRspInfo->ranFuncId; + + /* RIC Action Admitted List */ + ieIdx++; + subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx]; + subsRspIe->id = ProtocolIE_IDE2_id_RICactions_Admitted; + subsRspIe->criticality = CriticalityE2_reject; + subsRspIe->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List; + if(BuildRicActionAdmitList(&subsRspIe->value.choice.RICaction_Admitted_List, subsRspInfo) != ROK) + { + DU_LOG("\nERROR --> E2AP : Failed to fill RIC Action Admitted List in RIC Subscription Response"); + return RFAILED; + } - idx++; - ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactions_Admitted; - ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject; - ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\ - RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List; - BuildRicAdmitListret = - BuildRicAdmitList(&ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RICaction_Admitted_List); - if(BuildRicAdmitListret != ROK) - { - ret = RFAILED; - } - } + /* RIC Action Not Admitted List */ + if(subsRspInfo->numOfRejectedActions) + { + ieIdx++; + subsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx]; + subsRspIe->id = ProtocolIE_IDE2_id_RICactions_NotAdmitted; + subsRspIe->criticality = CriticalityE2_reject; + subsRspIe->criticality = CriticalityE2_reject; + subsRspIe->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List; + if(BuildRicActionNotAdmitList(&subsRspIe->value.choice.RICaction_NotAdmitted_List, subsRspInfo) != ROK) + { + DU_LOG("\nERROR --> E2AP : Failed to fill RIC Action Not Admitted List in RIC Subscription Response"); + return RFAILED; } - } - return ret; + } + + return ROK; } + /******************************************************************* * * @brief Builds and Send the RicSubscriptionRsp @@ -1446,14 +1450,12 @@ uint8_t FillRicSubscriptionRsp(RICsubscriptionResponse_t *ricSubscriptionRsp ) * ******************************************************************/ -uint8_t BuildAndSendRicSubscriptionRsp() +uint8_t BuildAndSendRicSubscriptionRsp(PendingSubsRspInfo *subsRspInfo) { - - E2AP_PDU_t *e2apRicMsg = NULLP; + uint8_t ret = RFAILED; + E2AP_PDU_t *e2apRicMsg = NULLP; RICsubscriptionResponse_t *ricSubscriptionRsp=NULLP; - asn_enc_rval_t encRetVal; - uint8_t ret = RFAILED; - uint8_t FillRicricSubscriptionRspret; + asn_enc_rval_t encRetVal; while(true) { @@ -1462,28 +1464,28 @@ uint8_t BuildAndSendRicSubscriptionRsp() DU_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t)); if(e2apRicMsg == NULLP) { - DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); - break; + DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed"); + break; } + e2apRicMsg->present = E2AP_PDU_PR_successfulOutcome; DU_ALLOC(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t)); if(e2apRicMsg->choice.successfulOutcome == NULLP) { - DU_LOG("\nERROR --> E2AP : Memory allocation for RIC subscription Response failed"); - break; + DU_LOG("\nERROR --> E2AP : Memory allocation for RIC subscription Response failed"); + break; } e2apRicMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription; e2apRicMsg->choice.successfulOutcome->criticality = CriticalityE2_reject; - e2apRicMsg->choice.successfulOutcome->value.present = \ - SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse; + e2apRicMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse; + ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse; - FillRicricSubscriptionRspret = FillRicSubscriptionRsp(ricSubscriptionRsp); - if(FillRicricSubscriptionRspret != ROK) + if(fillRicSubscriptionRsp(ricSubscriptionRsp, subsRspInfo) != ROK) { - DU_LOG("\nERROR --> E2AP : Memory allocation for RICsubscriptionResponseIE failed"); - break; + DU_LOG("\nERROR --> E2AP : Memory allocation for RICsubscriptionResponseIE failed"); + break; } /* Prints the Msg formed */ @@ -1491,37 +1493,36 @@ uint8_t BuildAndSendRicSubscriptionRsp() memset(encBuf, 0, ENC_BUF_MAX_LEN); encBufSize = 0; - encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf,\ - encBuf); + encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf, encBuf); if(encRetVal.encoded == ENCODE_FAIL) { - DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Response structure (at %s)\n",\ - encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); - break; + DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Response structure (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + break; } else { - DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription response \n"); + DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription response \n"); #ifdef DEBUG_ASN_PRINT - for(int i=0; i< encBufSize; i++) - { - printf("%x",encBuf[i]); - } + 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 RIC Subscription Response failed"); - break; + DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Response failed"); + break; } ret = ROK; break; } - FreeRicSubscriptionRsp(e2apRicMsg); + FreeRicSubscriptionRsp(e2apRicMsg); return ret; } @@ -1722,8 +1723,7 @@ void freeAperDecodingOfRicSubsReq(RICsubscriptionRequest_t *ricSubscriptionReq) { if(subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx]) { - actionItem = (RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.\ - list.array[elementIdx]; + actionItem = (RICaction_ToBeSetup_ItemIEs_t *)subsDetails->ricAction_ToBeSetup_List.list.array[elementIdx]; if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition) { free(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf); @@ -2175,7 +2175,7 @@ uint8_t extractRicActionDef(RanFunction *ranFuncDb, ActionDefinition *actionDefD * ******************************************************************/ uint8_t extractRicActionToBeSetup(RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo, \ - RICactions_ToBeSetup_List_t *actionList, E2FailureCause *failureCause) + RICactions_ToBeSetup_List_t *actionList, E2FailureCause *failureCause, PendingSubsRspInfo *subsRsp) { uint8_t actionIdx = 0; uint8_t ricActionId = 0; @@ -2194,9 +2194,10 @@ uint8_t extractRicActionToBeSetup(RanFunction *ranFuncDb, RicSubscription *ricSu * If RIC action definition's extraction and validation passes, * Then : * This action is added to action sequence list of subscription info */ + ricActionId = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID; + if(actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType == RICactionType_report) { - ricActionId = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID; ricSubscriptionInfo->actionSequence[ricActionId-1].id = ricActionId; ricSubscriptionInfo->actionSequence[ricActionId-1].type = REPORT; @@ -2205,14 +2206,22 @@ uint8_t extractRicActionToBeSetup(RanFunction *ranFuncDb, RicSubscription *ricSu { ricSubscriptionInfo->actionSequence[ricActionId-1].action = CONFIG_ADD; ricSubscriptionInfo->numOfActions++; + break; } - else - { - memset(&ricSubscriptionInfo->actionSequence[ricActionId-1], 0, sizeof(ActionInfo)); - /* TODO : Since this action addition failed, add to - * reject-action-list in subscription response */ - } } + + /* In case of any failure, action is rejected + * Added to rejected-action-list in subscription response */ + memset(&ricSubscriptionInfo->actionSequence[ricActionId-1], 0, sizeof(ActionInfo)); + subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].id = ricActionId; + if(failureCause->causeType == E2_NOTHING) + { + failureCause->causeType = E2_RIC_REQUEST; + failureCause->cause = E2_ACTION_NOT_SUPPORTED; + } + memcpy(&subsRsp->rejectedActionList[subsRsp->numOfRejectedActions].failureCause, \ + failureCause, sizeof(E2FailureCause)); + subsRsp->numOfRejectedActions++; break; } default: @@ -2291,6 +2300,14 @@ uint8_t procRicSubscriptionRequest(E2AP_PDU_t *e2apMsg) { ranFuncDb = &duCb.e2apDb.ranFunction[ranFuncId-1]; + if(ranFuncDb->numPendingSubsRsp >= MAX_PENDING_SUBSCRIPTION_RSP) + { + failureCause.causeType = E2_RIC_REQUEST; + failureCause.cause = E2_FUNCTION_RESOURCE_LIMIT; + ret = RFAILED; + break; + } + DU_ALLOC(ricSubscriptionInfo, sizeof(RicSubscription)); if(!ricSubscriptionInfo) { @@ -2302,6 +2319,11 @@ uint8_t procRicSubscriptionRequest(E2AP_PDU_t *e2apMsg) } ricSubscriptionInfo->requestId.requestorId = ricReqId.requestorId; ricSubscriptionInfo->requestId.instanceId = ricReqId.instanceId; + + memset(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp], 0, sizeof(PendingSubsRspInfo)); + memcpy(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp].requestId, + &ricReqId, sizeof(RicRequestId)); + ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp].ranFuncId = ranFuncId; } else { @@ -2326,7 +2348,7 @@ uint8_t procRicSubscriptionRequest(E2AP_PDU_t *e2apMsg) /* Decode, Validate and record RIC actions */ if(extractRicActionToBeSetup(ranFuncDb, ricSubscriptionInfo, &subsDetails->ricAction_ToBeSetup_List, \ - &failureCause) != ROK) + &failureCause, &ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp]) != ROK) { ret = RFAILED; break; @@ -2357,23 +2379,27 @@ uint8_t procRicSubscriptionRequest(E2AP_PDU_t *e2apMsg) cmLListAdd2Tail(&ranFuncDb->subscriptionList, ricSubscriptionNode); } + ranFuncDb->numPendingSubsRsp++; + #ifdef KPI_CALCULATION /* Send statistics request to other DU entities */ BuildAndSendStatsReq(ranFuncId, ricSubscriptionInfo); #endif - /* TODO : Trigger RIC subscription response once statistics response is + /* TODO : Trigger RIC Indication once statistics indication is * received from MAC . - * TBD in next gerrit */ - ret = BuildAndSendRicSubscriptionRsp(); - { - BuildAndSendRicIndication(ricSubscriptionInfo); - } + * TBD in future gerrit */ + //BuildAndSendRicIndication(ricSubscriptionInfo); } else { DU_FREE(ricSubscriptionInfo, sizeof(RicSubscription)); + if(ranFuncDb) + { + memset(&ranFuncDb->pendingSubsRspInfo[ranFuncDb->numPendingSubsRsp], 0, sizeof(PendingSubsRspInfo)); + } + /* Send RIC Subcription Failure */ BuildAndSendRicSubscriptionFailure(ricReqId, ranFuncId, failureCause); } @@ -4159,11 +4185,6 @@ void E2APMsgHdlr(Buffer *mBuf) procE2SetupFailure(e2apMsg); break; } - case UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure: - { - procRicServiceUpdateFailure(e2apMsg); - break; - } default: { DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_unsuccessfulOutcome [%d]",\ diff --git a/src/du_app/du_e2ap_msg_hdl.h b/src/du_app/du_e2ap_msg_hdl.h index 460355b9c..fffdfdbcd 100644 --- a/src/du_app/du_e2ap_msg_hdl.h +++ b/src/du_app/du_e2ap_msg_hdl.h @@ -20,14 +20,17 @@ #define ENCODE_FAIL -1 -uint8_t BuildAndSendE2SetupReq(); -uint8_t BuildAndSendE2NodeConfigUpdate(); +void E2APMsgHdlr(Buffer *mBuf); +uint8_t BuildAndSendE2SetupReq(); uint8_t BuildAndSendE2ResetRequest(E2FailureCause resetCause); -void E2APMsgHdlr(Buffer *mBuf); -uint8_t BuildAndSendRicIndication(RicSubscription *ricSubscriptionInfo); +uint8_t BuildAndSendE2NodeConfigUpdate(); uint8_t BuildAndSendRicServiceUpdate(RicServiceUpdate serviceUpdate); + uint8_t BuildAndSendStatsReq(uint16_t ranFuncId, RicSubscription *ricSubscriptionInfo); +uint8_t BuildAndSendRicSubscriptionRsp(PendingSubsRspInfo *subsRspInfo); uint8_t BuildAndSendRicSubscriptionFailure(RicRequestId ricReqId, uint16_t ranFuncId, E2FailureCause failureCause); +uint8_t BuildAndSendRicIndication(RicSubscription *ricSubscriptionInfo); + /********************************************************************** End of file **********************************************************************/ diff --git a/src/du_app/du_msg_hdl.c b/src/du_app/du_msg_hdl.c index 079585045..4559e9db8 100644 --- a/src/du_app/du_msg_hdl.c +++ b/src/du_app/du_msg_hdl.c @@ -2378,18 +2378,20 @@ uint8_t duRejectAllStatsGroup(RanFunction *ranFuncDb, CmLList *ricSubscriptionNo * ****************************************************************/ uint8_t DuProcMacStatsRsp(Pst *pst, MacStatsRsp *statsRsp) { + uint8_t idx = 0; + uint8_t actionId = 0; uint16_t ranFuncId = 0; RicRequestId ricReqId; RanFunction *ranFuncDb = NULLP; CmLList *ricSubscriptionNode = NULLP; RicSubscription *ricSubscriptionInfo = NULLP; + PendingSubsRspInfo *pendingSubsRsp = NULLP; DU_LOG("\nINFO --> DU_APP : DuProcMacStatsRsp: Received Statistics Response from MAC"); if(statsRsp) { #ifdef DEBUG_PRINT - uint8_t idx = 0; DU_LOG("\n Subscription Id [%ld]", statsRsp->subscriptionId); DU_LOG("\n Number of Accepted Groups [%d]", statsRsp->numGrpAccepted); @@ -2401,7 +2403,7 @@ uint8_t DuProcMacStatsRsp(Pst *pst, MacStatsRsp *statsRsp) DU_LOG("\n Number of Rejected Groups [%d]", statsRsp->numGrpRejected); for(idx=0; idxnumGrpRejected; idx++) { - DU_LOG("\n Group Id [%d]", statsRsp->statsGrpRejectedList[idx]); + DU_LOG("\n Group Id [%d]", statsRsp->statsGrpRejectedList[idx].groupId); } #endif @@ -2449,6 +2451,17 @@ uint8_t DuProcMacStatsRsp(Pst *pst, MacStatsRsp *statsRsp) return RFAILED; } + /* Fetch pre-stored statistics response info by DU APP */ + for(idx=0; idxnumPendingSubsRsp; idx++) + { + if((ranFuncDb->pendingSubsRspInfo[idx].requestId.requestorId == ricReqId.requestorId) && + (ricSubscriptionInfo->requestId.instanceId == ricReqId.instanceId)) + { + pendingSubsRsp = &ranFuncDb->pendingSubsRspInfo[idx]; + break; + } + } + /* If no action is accepted * a. Remove subcription entry from RAN Function * b. Send RIC subscription failure */ @@ -2456,23 +2469,51 @@ uint8_t DuProcMacStatsRsp(Pst *pst, MacStatsRsp *statsRsp) { duRejectAllStatsGroup(ranFuncDb, ricSubscriptionNode, statsRsp); } + else + { + /* If even 1 action is accepted : + * + * For accepted groups: + * Mark subscribed-action's -> action = CONFIG_UNKNOWN + * Add to accepted-action-list of subscription response + */ + for(idx=0; idxnumGrpAccepted; idx++) + { + actionId = statsRsp->statsGrpAcceptedList[idx]; + if((ricSubscriptionInfo->actionSequence[actionId-1].id == actionId) && + (ricSubscriptionInfo->actionSequence[actionId-1].action == CONFIG_ADD)) + { + ricSubscriptionInfo->actionSequence[actionId-1].action = CONFIG_UNKNOWN; - /* TODO : - * If even 1 action is accepted : - * - * For accepted groups: - * Mark scubscrbed-action's -> action = CONFIG_UNKNOWN - * Add action ID to accpeted-action-list in Subscription response - * - * For rejected groups: - * Remove entry from DU's RAN Function->subscription->actionList - * Add Rejected action Id to reject-action-list created by DU APP while - * processing of subscription request. - * - * Send subscription response with accepted and rejected action lists to - * RIC - */ + pendingSubsRsp->acceptedActionList[pendingSubsRsp->numOfAcceptedActions++] = actionId; + } + } + + /* For rejected groups: + * Remove entry from DU's RAN Function->subscription->actionList + * Add to rejected-action-list in subscription response + */ + for(idx=0; idxnumGrpRejected; idx++) + { + actionId = statsRsp->statsGrpRejectedList[idx].groupId; + if(ricSubscriptionInfo->actionSequence[actionId-1].id == actionId) + { + memset(&ricSubscriptionInfo->actionSequence[actionId-1], 0, sizeof(ActionInfo)); + ricSubscriptionInfo->numOfActions--; + + pendingSubsRsp->rejectedActionList[pendingSubsRsp->numOfRejectedActions].id = actionId; + convertDuCauseToE2Cause(statsRsp->statsGrpRejectedList[idx].cause, \ + &pendingSubsRsp->rejectedActionList[pendingSubsRsp->numOfRejectedActions].failureCause); + pendingSubsRsp->numOfRejectedActions++; + } + } + + /* Send subscription response with accepted and rejected action lists to + * RIC */ + BuildAndSendRicSubscriptionRsp(pendingSubsRsp); + } + memset(pendingSubsRsp, 0, sizeof(PendingSubsRspInfo)); DU_FREE_SHRABL_BUF(pst->region, pst->pool, statsRsp, sizeof(MacStatsRsp)); return ROK; } diff --git a/src/ric_stub/ric_e2ap_msg_hdl.c b/src/ric_stub/ric_e2ap_msg_hdl.c index 8cc3806d0..ac6dccbaa 100644 --- a/src/ric_stub/ric_e2ap_msg_hdl.c +++ b/src/ric_stub/ric_e2ap_msg_hdl.c @@ -890,7 +890,7 @@ uint8_t fillActionToBeSetup(RICaction_ToBeSetup_ItemIEs_t *actionItem, RicSubscr /* RIC Action ID */ actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID = ++ricActionId; - ricSubsDb->actionSequence[ricSubsDb->numOfActions].id = \ + ricSubsDb->actionSequence[ricActionId-1].id = \ actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID; /* RIC Action Type */ @@ -913,7 +913,7 @@ uint8_t fillActionToBeSetup(RICaction_ToBeSetup_ItemIEs_t *actionItem, RicSubscr return ROK; } - memset(&ricSubsDb->actionSequence[ricSubsDb->numOfActions], 0, sizeof(ActionInfo)); + memset(&ricSubsDb->actionSequence[ricActionId-1], 0, sizeof(ActionInfo)); return RFAILED; } @@ -1110,7 +1110,6 @@ uint8_t BuildAndSendRicSubscriptionReq(DuDb *duDb) RICsubscriptionRequest_t *ricSubscriptionReq; uint8_t elementCnt; uint8_t idx; - uint8_t ieId; asn_enc_rval_t encRetVal; /* Encoder return value */ RanFunction *ranFuncDb = &duDb->ranFunction[0]; @@ -1171,7 +1170,7 @@ uint8_t BuildAndSendRicSubscriptionReq(DuDb *duDb) if(BuildNewRicRequestId(&ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICrequestID, \ &ranFuncDb->subscriptionList[ranFuncDb->numOfSubscription].requestId) != ROK) { - DU_LOG("\nERROR --> E2AP : Failed at [%d] : Line [%d]", __func__, __LINE__); + DU_LOG("\nERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__); break; } @@ -1193,7 +1192,7 @@ uint8_t BuildAndSendRicSubscriptionReq(DuDb *duDb) if(BuildRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails),\ &ranFuncDb->subscriptionList[ranFuncDb->numOfSubscription]) != ROK) { - DU_LOG("\nERROR --> E2AP : Failed at [%d] : Line [%d]", __func__, __LINE__); + DU_LOG("\nERROR --> E2AP : Failed at [%s] : Line [%d]", __func__, __LINE__); break; } @@ -1250,16 +1249,98 @@ uint8_t BuildAndSendRicSubscriptionReq(DuDb *duDb) * ******************************************************************/ -void ProcRicSubscriptionResponse(uint32_t duId) +void ProcRicSubscriptionResponse(uint32_t duId, RICsubscriptionResponse_t *ricSubscriptionRsp) { - uint8_t duIdx = 0; - DuDb *duDb; + uint8_t duIdx = 0, ieIdx = 0,subsIdx = 0, notAdmitIdx = 0; + uint8_t ranFuncId = 0, actionId = 0; + DuDb *duDb = NULLP; + bool ricReqIdDecoded = false; + RicRequestId ricReqId; + RanFunction *ranFuncDb = NULLP; + RICsubscriptionResponse_IEs_t *ricSubsRspIe = NULLP; + RICaction_NotAdmitted_List_t *notAdmitList = NULLP; - DU_LOG("\nINFO --> E2AP : RICsubscriptionResponse Msg Acknowledged"); + DU_LOG("\nINFO --> E2AP : RIC Subscription Response received"); + /* Fetch DU DB */ SEARCH_DU_DB(duIdx, duId, duDb); - if(duDb) - duDb->ricSubscribedToDu = true; + if(duDb == NULLP) + { + DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId); + return; + } + + memset(&ricReqId, 0, sizeof(RicRequestId)); + if(ricSubscriptionRsp) + { + if(ricSubscriptionRsp->protocolIEs.list.array) + { + for(ieIdx=0; ieIdxprotocolIEs.list.count; ieIdx++) + { + if(ricSubscriptionRsp->protocolIEs.list.array[ieIdx]) + { + ricSubsRspIe = ricSubscriptionRsp->protocolIEs.list.array[ieIdx]; + switch(ricSubscriptionRsp->protocolIEs.list.array[ieIdx]->id) + { + case ProtocolIE_IDE2_id_RICrequestID: + { + ricReqId.requestorId = ricSubsRspIe->value.choice.RICrequestID.ricRequestorID; + ricReqId.instanceId = ricSubsRspIe->value.choice.RICrequestID.ricInstanceID; + ricReqIdDecoded = true; + break; + } + case ProtocolIE_IDE2_id_RANfunctionID: + { + ranFuncId = ricSubsRspIe->value.choice.RANfunctionID; + if(duDb->ranFunction[ranFuncId-1].id == ranFuncId) + { + ranFuncDb = &duDb->ranFunction[ranFuncId-1]; + } + else + { + DU_LOG("\nERROR --> E2AP : ProcRicSubscriptionResponse: RAN Function ID [%d] not found", ranFuncId); + return; + } + break; + } + case ProtocolIE_IDE2_id_RICactions_Admitted: + { + break; + } + case ProtocolIE_IDE2_id_RICactions_NotAdmitted: + { + if(!(ranFuncDb && ricReqIdDecoded)) + return; + + notAdmitList = &ricSubsRspIe->value.choice.RICaction_NotAdmitted_List; + for(notAdmitIdx = 0; notAdmitIdx < notAdmitList->list.count; notAdmitIdx++) + { + actionId = ((RICaction_NotAdmitted_ItemIEs_t *)(notAdmitList->list.array[notAdmitIdx]))->\ + value.choice.RICaction_NotAdmitted_Item.ricActionID; + + /* Remove action from RAN Function's subscription list */ + for(subsIdx = 0; subsIdx < ranFuncDb->numOfSubscription; subsIdx++) + { + if((ranFuncDb->subscriptionList[subsIdx].requestId.requestorId == ricReqId.requestorId) && + (ranFuncDb->subscriptionList[subsIdx].requestId.instanceId == ricReqId.instanceId)) + { + if(ranFuncDb->subscriptionList[subsIdx].actionSequence[actionId-1].id == actionId) + { + memset(&ranFuncDb->subscriptionList[subsIdx].actionSequence[actionId-1], 0, \ + sizeof(ActionInfo)); + ranFuncDb->subscriptionList[subsIdx].numOfActions--; + break; + } + } + } + } + break; + } + } + } + } + } + } } /******************************************************************* @@ -2811,7 +2892,7 @@ uint8_t ProcRicSubscriptionFailure(uint32_t duId, RICsubscriptionFailure_t *ricS if(duDb == NULLP) { DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId); - return; + return RFAILED; } memset(&ricReqId, 0, sizeof(RicRequestId)); @@ -2973,7 +3054,8 @@ void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf) default: { - DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]",e2apMsg->choice.initiatingMessage->value.present); + DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]", \ + e2apMsg->choice.initiatingMessage->value.present); return; } }/* End of switch(initiatingMessage) */ @@ -2985,12 +3067,14 @@ void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf) { case SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse: { - ProcRicSubscriptionResponse(*duId); + ProcRicSubscriptionResponse(*duId, \ + &e2apMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse); break; } default: { - DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]",e2apMsg->choice.successfulOutcome->value.present); + DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]", \ + e2apMsg->choice.successfulOutcome->value.present); return; } break; diff --git a/src/ric_stub/ric_stub.h b/src/ric_stub/ric_stub.h index 5213a7976..c8e52179f 100644 --- a/src/ric_stub/ric_stub.h +++ b/src/ric_stub/ric_stub.h @@ -133,7 +133,6 @@ typedef struct duDb uint16_t numOfRanFunction; RanFunction ranFunction[MAX_RAN_FUNCTION]; E2NodeComponent e2NodeComponent; - Bool ricSubscribedToDu; }DuDb; typedef struct ricCfgParams