diff --git a/openair2/COMMON/e1ap_messages_def.h b/openair2/COMMON/e1ap_messages_def.h index a5b9422f14..83de2f82c8 100644 --- a/openair2/COMMON/e1ap_messages_def.h +++ b/openair2/COMMON/e1ap_messages_def.h @@ -38,6 +38,8 @@ MESSAGE_DEF(E1AP_SETUP_FAIL, MESSAGE_PRIORITY_MED, e1ap_setup_fail_t, e1ap_setup MESSAGE_DEF(E1AP_BEARER_CONTEXT_SETUP_REQ , MESSAGE_PRIORITY_MED , e1ap_bearer_setup_req_t , e1ap_bearer_setup_req) /* E1AP Bearer Context Setup Response: gNB-CU-UP -> gNB-CU-CP */ MESSAGE_DEF(E1AP_BEARER_CONTEXT_SETUP_RESP , MESSAGE_PRIORITY_MED , e1ap_bearer_setup_resp_t , e1ap_bearer_setup_resp) +/* E1AP Bearer Context Setup Failure: gNB-CU-UP -> gNB-CU-CP */ +MESSAGE_DEF(E1AP_BEARER_CONTEXT_SETUP_FAILURE , MESSAGE_PRIORITY_MED , e1ap_bearer_context_setup_failure_t , e1ap_bearer_setup_fail) /* E1AP Bearer Context Modification Request: gNB-CU-CP -> gNB-CU-UP */ MESSAGE_DEF(E1AP_BEARER_CONTEXT_MODIFICATION_REQ , MESSAGE_PRIORITY_MED , e1ap_bearer_mod_req_t , e1ap_bearer_mod_req) /* E1AP Bearer Context Modification Response: gNB-CU-UP -> gNB-CU-CP */ diff --git a/openair2/COMMON/e1ap_messages_types.h b/openair2/COMMON/e1ap_messages_types.h index ccac11b19d..0cfeb7fd73 100644 --- a/openair2/COMMON/e1ap_messages_types.h +++ b/openair2/COMMON/e1ap_messages_types.h @@ -50,6 +50,7 @@ #define E1AP_SETUP_FAIL(mSGpTR) (mSGpTR)->ittiMsg.e1ap_setup_fail #define E1AP_BEARER_CONTEXT_SETUP_REQ(mSGpTR) (mSGpTR)->ittiMsg.e1ap_bearer_setup_req #define E1AP_BEARER_CONTEXT_SETUP_RESP(mSGpTR) (mSGpTR)->ittiMsg.e1ap_bearer_setup_resp +#define E1AP_BEARER_CONTEXT_SETUP_FAILURE(mSGpTR) (mSGpTR)->ittiMsg.e1ap_bearer_setup_fail #define E1AP_BEARER_CONTEXT_MODIFICATION_REQ(mSGpTR) (mSGpTR)->ittiMsg.e1ap_bearer_mod_req #define E1AP_BEARER_CONTEXT_MODIFICATION_RESP(mSGpTR) (mSGpTR)->ittiMsg.e1ap_bearer_modif_resp #define E1AP_BEARER_CONTEXT_RELEASE_CMD(mSGpTR) (mSGpTR)->ittiMsg.e1ap_bearer_release_cmd @@ -478,6 +479,16 @@ typedef struct e1ap_bearer_setup_req_s { pdu_session_to_setup_t pduSession[E1AP_MAX_NUM_PDU_SESSIONS]; } e1ap_bearer_setup_req_t; +/** Bearer Context Setup Failure (9.2.2.3 3GPP TS 38.463) */ +typedef struct e1ap_bearer_context_setup_failure_s { + // gNB-CU-CP UE E1AP ID (M) + uint32_t gNB_cu_cp_ue_id; + // gNB-CU-UP UE E1AP ID (O) + uint32_t *gNB_cu_up_ue_id; + // Cause (M) + e1ap_cause_t cause; +} e1ap_bearer_context_setup_failure_t; + /** * Bearer Context Modification Request, clause 9.2.2.4 of 3GPP TS 38.463 */ diff --git a/openair2/E1AP/e1ap.c b/openair2/E1AP/e1ap.c index f0e4d5578d..42baaaa165 100644 --- a/openair2/E1AP/e1ap.c +++ b/openair2/E1AP/e1ap.c @@ -386,10 +386,10 @@ void e1apCUUP_send_BEARER_CONTEXT_SETUP_RESPONSE(sctp_assoc_t assoc_id, const e1 e1ap_encode_send(UPtype, assoc_id, pdu, 0, __func__); } -int e1apCUUP_send_BEARER_CONTEXT_SETUP_FAILURE(instance_t instance) +static void e1apCUUP_send_BEARER_CONTEXT_SETUP_FAILURE(sctp_assoc_t assoc_id, const e1ap_bearer_context_setup_failure_t *msg) { - AssertFatal(false, "Not implemented yet\n"); - return -1; + E1AP_E1AP_PDU_t *pdu = encode_E1_bearer_context_setup_failure(msg); + e1ap_encode_send(UPtype, assoc_id, pdu, 0, __func__); } int e1apCUUP_handle_BEARER_CONTEXT_SETUP_REQUEST(sctp_assoc_t assoc_id, e1ap_upcp_inst_t *e1_inst, const E1AP_E1AP_PDU_t *pdu) @@ -423,8 +423,20 @@ int e1apCUCP_handle_BEARER_CONTEXT_SETUP_RESPONSE(sctp_assoc_t assoc_id, e1ap_up int e1apCUCP_handle_BEARER_CONTEXT_SETUP_FAILURE(sctp_assoc_t assoc_id, e1ap_upcp_inst_t *inst, const E1AP_E1AP_PDU_t *pdu) { - AssertFatal(false, "Not implemented yet\n"); - return -1; + e1ap_bearer_context_setup_failure_t fail = {0}; + if (!decode_E1_bearer_context_setup_failure(&fail, pdu)) { + LOG_E(E1AP, "Failed to decode Bearer Context Setup Failure\n"); + free_e1_bearer_context_setup_failure(&fail); + return -1; + } + LOG_E(E1AP, "Received Bearer Context Setup Failure with cause value%d \n", fail.cause.value); + + MessageDef *msg = itti_alloc_new_message(TASK_CUCP_E1, 0, E1AP_BEARER_CONTEXT_SETUP_FAILURE); + E1AP_BEARER_CONTEXT_SETUP_FAILURE(msg) = fail; + msg->ittiMsgHeader.originInstance = assoc_id; + instance_t instance = 0; + itti_send_msg_to_task(TASK_RRC_GNB, instance, msg); + return 0; } static void e1apCUCP_send_BEARER_CONTEXT_MODIFICATION_REQUEST(sctp_assoc_t assoc_id, e1ap_bearer_mod_req_t *const bearerCxt) @@ -1028,6 +1040,14 @@ void *E1AP_CUUP_task(void *arg) free_e1ap_context_setup_response(resp); } break; + case E1AP_BEARER_CONTEXT_SETUP_FAILURE: { + const e1ap_bearer_context_setup_failure_t *fail = &E1AP_BEARER_CONTEXT_SETUP_FAILURE(msg); + const e1ap_upcp_inst_t *inst = getCxtE1(myInstance); + AssertFatal(inst, "no E1 instance found for instance %ld\n", myInstance); + e1apCUUP_send_BEARER_CONTEXT_SETUP_FAILURE(inst->cuup.assoc_id, fail); + free_e1_bearer_context_setup_failure(fail); + } break; + case E1AP_BEARER_CONTEXT_MODIFICATION_RESP: { const e1ap_bearer_modif_resp_t *resp = &E1AP_BEARER_CONTEXT_MODIFICATION_RESP(msg); const e1ap_upcp_inst_t *inst = getCxtE1(myInstance); diff --git a/openair2/E1AP/lib/e1ap_bearer_context_management.c b/openair2/E1AP/lib/e1ap_bearer_context_management.c index 81ac737cf6..be8b37ee45 100644 --- a/openair2/E1AP/lib/e1ap_bearer_context_management.c +++ b/openair2/E1AP/lib/e1ap_bearer_context_management.c @@ -1075,6 +1075,120 @@ void free_e1ap_context_setup_response(const e1ap_bearer_setup_resp_t *msg) // Do nothing (no dynamic allocation) } +/* ===================================== + * E1AP Bearer Context Setup Failure + * ===================================== */ + +/** + * @brief Bearer Context Setup Failure encoding (9.2.2.3, 3GPP TS 38.463) + * gNB-CU-UP → gNB-CU-CP + */ +E1AP_E1AP_PDU_t *encode_E1_bearer_context_setup_failure(const e1ap_bearer_context_setup_failure_t *msg) +{ + E1AP_E1AP_PDU_t *pdu = calloc_or_fail(1, sizeof(*pdu)); + pdu->present = E1AP_E1AP_PDU_PR_unsuccessfulOutcome; + + // Type (M) + asn1cCalloc(pdu->choice.unsuccessfulOutcome, type); + type->procedureCode = E1AP_ProcedureCode_id_bearerContextSetup; + type->criticality = E1AP_Criticality_reject; + type->value.present = E1AP_UnsuccessfulOutcome__value_PR_BearerContextSetupFailure; + E1AP_BearerContextSetupFailure_t *out = &pdu->choice.unsuccessfulOutcome->value.choice.BearerContextSetupFailure; + + // gNB-CU-CP UE E1AP ID (M) + asn1cSequenceAdd(out->protocolIEs.list, E1AP_BearerContextSetupFailureIEs_t, ie1); + ie1->id = E1AP_ProtocolIE_ID_id_gNB_CU_CP_UE_E1AP_ID; + ie1->criticality = E1AP_Criticality_reject; + ie1->value.present = E1AP_BearerContextSetupFailureIEs__value_PR_GNB_CU_CP_UE_E1AP_ID; + ie1->value.choice.GNB_CU_CP_UE_E1AP_ID = msg->gNB_cu_cp_ue_id; + + // gNB-CU-UP UE E1AP ID (O) + if (msg->gNB_cu_up_ue_id) { + asn1cSequenceAdd(out->protocolIEs.list, E1AP_BearerContextSetupFailureIEs_t, ie2); + ie2->id = E1AP_ProtocolIE_ID_id_gNB_CU_UP_UE_E1AP_ID; + ie2->criticality = E1AP_Criticality_reject; + ie2->value.present = E1AP_BearerContextSetupFailureIEs__value_PR_GNB_CU_UP_UE_E1AP_ID; + ie2->value.choice.GNB_CU_UP_UE_E1AP_ID = *msg->gNB_cu_up_ue_id; + } + + // Cause (M) + asn1cSequenceAdd(out->protocolIEs.list, E1AP_BearerContextSetupFailureIEs_t, ie3); + ie3->id = E1AP_ProtocolIE_ID_id_Cause; + ie3->criticality = E1AP_Criticality_reject; + ie3->value.present = E1AP_BearerContextSetupFailureIEs__value_PR_Cause; + ie3->value.choice.Cause = e1_encode_cause_ie(&msg->cause); + + return pdu; +} + +/** + * @brief Bearer Context Setup Failure decoding (9.2.2.3, 3GPP TS 38.463) + * gNB-CU-UP → gNB-CU-CP + */ +bool decode_E1_bearer_context_setup_failure(e1ap_bearer_context_setup_failure_t *out, const E1AP_E1AP_PDU_t *pdu) +{ + DevAssert(pdu != NULL); + _E1_EQ_CHECK_INT(pdu->present, E1AP_E1AP_PDU_PR_unsuccessfulOutcome); + E1AP_UnsuccessfulOutcome_t *type = pdu->choice.unsuccessfulOutcome; + _E1_EQ_CHECK_LONG(type->procedureCode, E1AP_ProcedureCode_id_bearerContextSetup); + _E1_EQ_CHECK_INT(type->value.present, E1AP_UnsuccessfulOutcome__value_PR_BearerContextSetupFailure); + const E1AP_BearerContextSetupFailure_t *in = &type->value.choice.BearerContextSetupFailure; + + // Check mandatory IEs first + E1AP_BearerContextSetupFailureIEs_t *ie; + E1AP_LIB_FIND_IE(E1AP_BearerContextSetupFailureIEs_t, ie, in, E1AP_ProtocolIE_ID_id_gNB_CU_CP_UE_E1AP_ID, true); + E1AP_LIB_FIND_IE(E1AP_BearerContextSetupFailureIEs_t, ie, in, E1AP_ProtocolIE_ID_id_Cause, true); + + for (int i = 0; i < in->protocolIEs.list.count; i++) { + ie = in->protocolIEs.list.array[i]; + AssertFatal(ie != NULL, "in->protocolIEs.list.array[i] shall not be null"); + switch (ie->id) { + case E1AP_ProtocolIE_ID_id_gNB_CU_CP_UE_E1AP_ID: + out->gNB_cu_cp_ue_id = ie->value.choice.GNB_CU_CP_UE_E1AP_ID; + break; + case E1AP_ProtocolIE_ID_id_gNB_CU_UP_UE_E1AP_ID: + out->gNB_cu_up_ue_id = malloc_or_fail(sizeof(*out->gNB_cu_up_ue_id)); + *out->gNB_cu_up_ue_id = ie->value.choice.GNB_CU_UP_UE_E1AP_ID; + break; + case E1AP_ProtocolIE_ID_id_Cause: + out->cause = e1_decode_cause_ie(&ie->value.choice.Cause); + break; + default: + break; + } + } + return true; +} + +/** @brief Bearer Context Setup Failure deep copy */ +e1ap_bearer_context_setup_failure_t cp_bearer_context_setup_failure(const e1ap_bearer_context_setup_failure_t *msg) +{ + // Shallow copy + e1ap_bearer_context_setup_failure_t cp = *msg; + if (msg->gNB_cu_up_ue_id) { + cp.gNB_cu_up_ue_id = malloc_or_fail(sizeof(*cp.gNB_cu_up_ue_id)); + *cp.gNB_cu_up_ue_id = *msg->gNB_cu_up_ue_id; + } + return cp; +} + +/** @brief Bearer Context Setup Failure equality check */ +bool eq_bearer_context_setup_failure(const e1ap_bearer_context_setup_failure_t *a, const e1ap_bearer_context_setup_failure_t *b) +{ + _E1_EQ_CHECK_INT(a->gNB_cu_cp_ue_id, b->gNB_cu_cp_ue_id); + _E1_EQ_CHECK_OPTIONAL_IE(a, b, gNB_cu_up_ue_id, _E1_EQ_CHECK_INT); + _E1_EQ_CHECK_INT(a->cause.type, b->cause.type); + _E1_EQ_CHECK_INT(a->cause.value, b->cause.value); + return true; +} + +/** @brief Bearer Context Setup Failure equality check */ +void free_e1_bearer_context_setup_failure(const e1ap_bearer_context_setup_failure_t *msg) +{ + free(msg->gNB_cu_up_ue_id); + // do nothing +} + /* ============================================ * E1AP Bearer Context Modification Request * ============================================ */ diff --git a/openair2/E1AP/lib/e1ap_bearer_context_management.h b/openair2/E1AP/lib/e1ap_bearer_context_management.h index fb8c57e011..86c2ca0635 100644 --- a/openair2/E1AP/lib/e1ap_bearer_context_management.h +++ b/openair2/E1AP/lib/e1ap_bearer_context_management.h @@ -40,6 +40,12 @@ void free_e1ap_context_setup_response(const e1ap_bearer_setup_resp_t *msg); e1ap_bearer_setup_resp_t cp_bearer_context_setup_response(const e1ap_bearer_setup_resp_t *msg); bool eq_bearer_context_setup_response(const e1ap_bearer_setup_resp_t *a, const e1ap_bearer_setup_resp_t *b); +struct E1AP_E1AP_PDU *encode_E1_bearer_context_setup_failure(const e1ap_bearer_context_setup_failure_t *msg); +bool decode_E1_bearer_context_setup_failure(e1ap_bearer_context_setup_failure_t *out, const struct E1AP_E1AP_PDU *pdu); +e1ap_bearer_context_setup_failure_t cp_bearer_context_setup_failure(const e1ap_bearer_context_setup_failure_t *msg); +bool eq_bearer_context_setup_failure(const e1ap_bearer_context_setup_failure_t *a, const e1ap_bearer_context_setup_failure_t *b); +void free_e1_bearer_context_setup_failure(const e1ap_bearer_context_setup_failure_t *msg); + struct E1AP_E1AP_PDU *encode_E1_bearer_context_mod_request(const e1ap_bearer_mod_req_t *msg); bool decode_E1_bearer_context_mod_request(const struct E1AP_E1AP_PDU *pdu, e1ap_bearer_mod_req_t *out); void free_e1ap_context_mod_request(const e1ap_bearer_mod_req_t *msg); diff --git a/openair2/E1AP/tests/e1ap_lib_test.c b/openair2/E1AP/tests/e1ap_lib_test.c index 68ce89cae1..bae85684de 100644 --- a/openair2/E1AP/tests/e1ap_lib_test.c +++ b/openair2/E1AP/tests/e1ap_lib_test.c @@ -222,6 +222,50 @@ static void test_bearer_context_setup_response(void) free_e1ap_context_setup_response(&orig); } +/** @brief Test E1AP Bearer Context Setup Failure encoding/decoding */ +static void test_bearer_context_setup_failure(void) +{ + e1ap_bearer_context_setup_failure_t orig = { + .gNB_cu_cp_ue_id = 0x1234, + .gNB_cu_up_ue_id = malloc_or_fail(sizeof(*orig.gNB_cu_up_ue_id)), + .cause.type = E1AP_Cause_PR_radioNetwork, + .cause.value = 11, + }; + *orig.gNB_cu_up_ue_id = 0x5678; + + // Encode the original message + E1AP_E1AP_PDU_t *enc = encode_E1_bearer_context_setup_failure(&orig); + + // E1AP decode the encoded message + E1AP_E1AP_PDU_t *dec = e1ap_encode_decode(enc); + + // Free the E1AP encoded message + e1ap_msg_free(enc); + + // Decode the encoded message + e1ap_bearer_context_setup_failure_t decoded = {0}; + bool ret = decode_E1_bearer_context_setup_failure(&decoded, dec); + AssertFatal(ret, "decode_E1_bearer_context_setup_failure failed"); + + // Free the E1AP decoded message + e1ap_msg_free(dec); + + // Equality check original/decoded + AssertFatal(eq_bearer_context_setup_failure(&orig, &decoded), "eq_bearer_context_mod_failure: decoded message does not match original"); + + // Free the memory for the decoded message + free_e1_bearer_context_setup_failure(&decoded); + + // Deep copy and equality check of the original message + e1ap_bearer_context_setup_failure_t cp = cp_bearer_context_setup_failure(&orig); + AssertFatal(eq_bearer_context_setup_failure(&orig, &cp), "eq_bearer_context_setup_failure(): copied message doesn't match\n"); + + // Cleanup + free_e1_bearer_context_setup_failure(&orig); + free_e1_bearer_context_setup_failure(&cp); +} + + /** * @brief Test CU-UP Setup Request encoding/decoding */ @@ -622,6 +666,7 @@ int main() // E1 Bearer Context Setup test_bearer_context_setup_request(); test_bearer_context_setup_response(); + test_bearer_context_setup_failure(); // E1 Interface Management test_e1_cuup_setup_request(); test_e1_cuup_setup_response(); diff --git a/openair2/RRC/NR/rrc_gNB.c b/openair2/RRC/NR/rrc_gNB.c index a110e4af53..8f6be46f19 100644 --- a/openair2/RRC/NR/rrc_gNB.c +++ b/openair2/RRC/NR/rrc_gNB.c @@ -2551,6 +2551,16 @@ void rrc_gNB_process_e1_bearer_context_setup_resp(e1ap_bearer_setup_resp_t *resp rrc_gNB_generate_UeContextModificationRequest(rrc, ue_context_p, nb_drb, drbs, 0, NULL); } +/** @brief E1AP Bearer Context Setup Failure processing on CU-CP */ +void rrc_gNB_process_e1_bearer_context_setup_failure(e1ap_bearer_context_setup_failure_t *msg) +{ + LOG_E(RRC, + "Received E1AP Bearer Context Setup Failure for UE CU-CP ID %d with cause (%d, %d)\n", + msg->gNB_cu_cp_ue_id, + msg->cause.type, + msg->cause.value); +} + /** * @brief E1AP Bearer Context Modification Response processing on CU-CP */ @@ -2864,6 +2874,11 @@ void *rrc_gnb_task(void *args_p) { free_e1ap_context_setup_response(&E1AP_BEARER_CONTEXT_SETUP_RESP(msg_p)); break; + case E1AP_BEARER_CONTEXT_SETUP_FAILURE: + rrc_gNB_process_e1_bearer_context_setup_failure(&E1AP_BEARER_CONTEXT_SETUP_FAILURE(msg_p)); + free_e1_bearer_context_setup_failure(&E1AP_BEARER_CONTEXT_SETUP_FAILURE(msg_p)); + break; + case E1AP_BEARER_CONTEXT_MODIFICATION_RESP: rrc_gNB_process_e1_bearer_context_modif_resp(&E1AP_BEARER_CONTEXT_MODIFICATION_RESP(msg_p)); free_e1ap_context_mod_response(&E1AP_BEARER_CONTEXT_MODIFICATION_RESP(msg_p));