From 306a44ebff1360c502b59513a0e56a58c05f0faa Mon Sep 17 00:00:00 2001 From: Guido Casati Date: Wed, 20 Nov 2024 19:57:11 +0100 Subject: [PATCH 1/2] Add enc/dec lib and unit test for E1AP Bearer Context Modification Failure --- openair2/COMMON/e1ap_messages_types.h | 9 ++ .../E1AP/lib/e1ap_bearer_context_management.c | 98 +++++++++++++++++++ .../E1AP/lib/e1ap_bearer_context_management.h | 6 ++ openair2/E1AP/tests/e1ap_lib_test.c | 46 ++++++++- 4 files changed, 158 insertions(+), 1 deletion(-) diff --git a/openair2/COMMON/e1ap_messages_types.h b/openair2/COMMON/e1ap_messages_types.h index ccac11b19d..adcff5e8cd 100644 --- a/openair2/COMMON/e1ap_messages_types.h +++ b/openair2/COMMON/e1ap_messages_types.h @@ -615,5 +615,14 @@ typedef struct e1ap_lost_connection_t { int dummy; } e1ap_lost_connection_t; +/// @brief 9.2.2.6 BEARER CONTEXT MODIFICATION FAILURE +typedef struct e1ap_bearer_context_mod_failure_s { + // gNB-CU-CP UE E1AP ID (M) + uint32_t gNB_cu_cp_ue_id; + // gNB-CU-UP UE E1AP ID (M) + uint32_t gNB_cu_up_ue_id; + // NG-RAN PDU Session Resource Modified List (O) + e1ap_cause_t cause; +} e1ap_bearer_context_mod_failure_t; #endif /* E1AP_MESSAGES_TYPES_H */ diff --git a/openair2/E1AP/lib/e1ap_bearer_context_management.c b/openair2/E1AP/lib/e1ap_bearer_context_management.c index 81ac737cf6..b14d132880 100644 --- a/openair2/E1AP/lib/e1ap_bearer_context_management.c +++ b/openair2/E1AP/lib/e1ap_bearer_context_management.c @@ -2128,3 +2128,101 @@ void free_e1ap_context_mod_response(const e1ap_bearer_modif_resp_t *msg) free(msg->pduSessionMod[i].ng_DL_UP_TL_info); } } + +/* =========================================== + * E1AP Bearer Context Modification Failure + * ============================================ */ + +/** @brief Bearer Context Modification Failure encoding (9.2.2.6 38.463) + * gNB-CU-UP → gNB-CU-CP */ +struct E1AP_E1AP_PDU *encode_E1_bearer_context_mod_failure(const e1ap_bearer_context_mod_failure_t *msg) +{ + E1AP_E1AP_PDU_t *pdu = calloc_or_fail(1, sizeof(*pdu)); + pdu->present = E1AP_E1AP_PDU_PR_unsuccessfulOutcome; + asn1cCalloc(pdu->choice.unsuccessfulOutcome, type); + type->procedureCode = E1AP_ProcedureCode_id_bearerContextModification; + type->criticality = E1AP_Criticality_reject; + type->value.present = E1AP_UnsuccessfulOutcome__value_PR_BearerContextModificationFailure; + E1AP_BearerContextModificationFailure_t *out = &type->value.choice.BearerContextModificationFailure; + // gNB-CU-CP UE E1AP ID (M) + asn1cSequenceAdd(out->protocolIEs.list, E1AP_BearerContextModificationFailureIEs_t, ie1); + ie1->id = E1AP_ProtocolIE_ID_id_gNB_CU_CP_UE_E1AP_ID; + ie1->criticality = E1AP_Criticality_reject; + ie1->value.present = E1AP_BearerContextModificationFailureIEs__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 (M) + asn1cSequenceAdd(out->protocolIEs.list, E1AP_BearerContextModificationFailureIEs_t, ie2); + ie2->id = E1AP_ProtocolIE_ID_id_gNB_CU_UP_UE_E1AP_ID; + ie2->criticality = E1AP_Criticality_reject; + ie2->value.present = E1AP_BearerContextModificationFailureIEs__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_BearerContextModificationFailureIEs_t, ie3); + ie3->id = E1AP_ProtocolIE_ID_id_Cause; + ie3->criticality = E1AP_Criticality_reject; + ie3->value.present = E1AP_BearerContextModificationFailureIEs__value_PR_Cause; + ie3->value.choice.Cause = e1_encode_cause_ie(&msg->cause); + return pdu; +} + +/** @brief Bearer Context Modification Failure decoding (9.2.2.6 38.463) + * gNB-CU-UP → gNB-CU-CP */ +bool decode_E1_bearer_context_mod_failure(e1ap_bearer_context_mod_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_bearerContextModification); + _E1_EQ_CHECK_INT(type->value.present, E1AP_UnsuccessfulOutcome__value_PR_BearerContextModificationFailure); + const E1AP_BearerContextModificationFailure_t *in = &type->value.choice.BearerContextModificationFailure; + // Check mandatory IEs first + E1AP_BearerContextModificationFailureIEs_t *ie; + E1AP_LIB_FIND_IE(E1AP_BearerContextModificationFailureIEs_t, ie, in, E1AP_ProtocolIE_ID_id_gNB_CU_CP_UE_E1AP_ID, true); + E1AP_LIB_FIND_IE(E1AP_BearerContextModificationFailureIEs_t, ie, in, E1AP_ProtocolIE_ID_id_gNB_CU_UP_UE_E1AP_ID, true); + E1AP_LIB_FIND_IE(E1AP_BearerContextModificationFailureIEs_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 = 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: + PRINT_ERROR("Invalid or unhandled optional IE (%ld) in Bearer Context Modification Failure message\n", ie->id); + break; + } + } + return true; +} + +/** @brief E1AP Bearer Context Modification Failure: deep copy */ +e1ap_bearer_context_mod_failure_t cp_E1_bearer_context_mod_failure(const e1ap_bearer_context_mod_failure_t *msg) +{ + e1ap_bearer_context_mod_failure_t cp = {0}; + cp = *msg; + return cp; +} + +/** @brief E1AP Bearer Context Modification Failure: equality check */ +bool eq_E1_bearer_context_mod_failure(const e1ap_bearer_context_mod_failure_t *a, const e1ap_bearer_context_mod_failure_t *b) +{ + if (!a || !b) + return false; // Null-check both inputs + _E1_EQ_CHECK_INT(a->gNB_cu_cp_ue_id, b->gNB_cu_cp_ue_id); + _E1_EQ_CHECK_INT(a->gNB_cu_up_ue_id, b->gNB_cu_up_ue_id); + _E1_EQ_CHECK_INT(a->cause.type, b->cause.type); + _E1_EQ_CHECK_INT(a->cause.value, b->cause.value); + return true; +} + +/** @brief E1AP Bearer Context Modification Failure: free */ +void free_E1_bearer_context_mod_failure(const e1ap_bearer_context_mod_failure_t *msg) +{ + // do nothing +} diff --git a/openair2/E1AP/lib/e1ap_bearer_context_management.h b/openair2/E1AP/lib/e1ap_bearer_context_management.h index fb8c57e011..6565f31749 100644 --- a/openair2/E1AP/lib/e1ap_bearer_context_management.h +++ b/openair2/E1AP/lib/e1ap_bearer_context_management.h @@ -52,4 +52,10 @@ void free_e1ap_context_mod_response(const e1ap_bearer_modif_resp_t *msg); e1ap_bearer_modif_resp_t cp_bearer_context_mod_response(const e1ap_bearer_modif_resp_t *msg); bool eq_bearer_context_mod_response(const e1ap_bearer_modif_resp_t *a, const e1ap_bearer_modif_resp_t *b); +struct E1AP_E1AP_PDU *encode_E1_bearer_context_mod_failure(const e1ap_bearer_context_mod_failure_t *msg); +bool decode_E1_bearer_context_mod_failure(e1ap_bearer_context_mod_failure_t *out, const struct E1AP_E1AP_PDU *pdu); +void free_E1_bearer_context_mod_failure(const e1ap_bearer_context_mod_failure_t *msg); +e1ap_bearer_context_mod_failure_t cp_E1_bearer_context_mod_failure(const e1ap_bearer_context_mod_failure_t *msg); +bool eq_E1_bearer_context_mod_failure(const e1ap_bearer_context_mod_failure_t *a, const e1ap_bearer_context_mod_failure_t *b); + #endif /* E1AP_BEARER_CONTEXT_MANAGEMENT_H_ */ diff --git a/openair2/E1AP/tests/e1ap_lib_test.c b/openair2/E1AP/tests/e1ap_lib_test.c index 68ce89cae1..e7102bc904 100644 --- a/openair2/E1AP/tests/e1ap_lib_test.c +++ b/openair2/E1AP/tests/e1ap_lib_test.c @@ -617,6 +617,49 @@ static void test_bearer_context_modification_response_fail(void) free_e1ap_context_mod_response(&orig); } +/** @brief Test E1AP Bearer Context Modification Failure encoding/decoding */ +static void test_bearer_context_modification_failure(void) +{ + // Create the original failure struct + e1ap_bearer_context_mod_failure_t orig = { + .gNB_cu_cp_ue_id = 0x1111, + .gNB_cu_up_ue_id = 0x2222, + .cause.type = E1AP_CAUSE_TRANSPORT, + .cause.value = E1AP_TRANSPORT_CAUSE_RESOURCE_UNAVAILABLE, + }; + + // Encode the original message + E1AP_E1AP_PDU_t *enc = encode_E1_bearer_context_mod_failure(&orig); + + // Decode the encoded message + E1AP_E1AP_PDU_t *dec = e1ap_encode_decode(enc); + + // Free the encoded message + e1ap_msg_free(enc); + + // Decode into a new struct + e1ap_bearer_context_mod_failure_t decoded = {0}; + AssertFatal(decode_E1_bearer_context_mod_failure(&decoded, dec), + "decode_E1_bearer_context_mod_failure(): could not decode message\n"); + + // Free the decoded PDU + e1ap_msg_free(dec); + + // Compare original and decoded messages + AssertFatal(eq_E1_bearer_context_mod_failure(&orig, &decoded), + "eq_E1_bearer_context_mod_failure(): decoded message doesn't match\n"); + + // Deep copy the original message + e1ap_bearer_context_mod_failure_t cp = cp_E1_bearer_context_mod_failure(&orig); + + // Compare original and copied messages + AssertFatal(eq_E1_bearer_context_mod_failure(&orig, &cp), "eq_E1_bearer_context_mod_failure(): copied message doesn't match\n"); + + // Free the decoded and copied messages + free_E1_bearer_context_mod_failure(&decoded); + free_E1_bearer_context_mod_failure(&cp); +} + int main() { // E1 Bearer Context Setup @@ -626,9 +669,10 @@ int main() test_e1_cuup_setup_request(); test_e1_cuup_setup_response(); test_e1_cuup_setup_failure(); - // E1 Bearer Context Modification Request + // E1 Bearer Context Modification test_bearer_context_modification_request(); test_bearer_context_modification_response(); test_bearer_context_modification_response_fail(); + test_bearer_context_modification_failure(); return 0; } From 79df7395983a783ad6bc610ca8029cfe5e7bfce4 Mon Sep 17 00:00:00 2001 From: Guido Casati Date: Wed, 20 Nov 2024 19:57:24 +0100 Subject: [PATCH 2/2] Add callback/handler for E1AP Bearer Context Modification Failure --- openair2/COMMON/e1ap_messages_def.h | 2 ++ openair2/COMMON/e1ap_messages_types.h | 1 + openair2/E1AP/e1ap.c | 37 +++++++++++++++++++-------- openair2/E1AP/e1ap.h | 2 ++ openair2/RRC/NR/rrc_gNB.c | 21 +++++++++++++++ 5 files changed, 53 insertions(+), 10 deletions(-) diff --git a/openair2/COMMON/e1ap_messages_def.h b/openair2/COMMON/e1ap_messages_def.h index a5b9422f14..d5de6e8f56 100644 --- a/openair2/COMMON/e1ap_messages_def.h +++ b/openair2/COMMON/e1ap_messages_def.h @@ -42,6 +42,8 @@ MESSAGE_DEF(E1AP_BEARER_CONTEXT_SETUP_RESP , MESSAGE_PRIORITY_MED , e1ap_bearer_ 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 */ MESSAGE_DEF(E1AP_BEARER_CONTEXT_MODIFICATION_RESP, MESSAGE_PRIORITY_MED, e1ap_bearer_modif_resp_t, e1ap_bearer_modif_resp) +/* E1AP Bearer Context Modification Failure: gNB-CU-UP -> gNB-CU-CP */ +MESSAGE_DEF(E1AP_BEARER_CONTEXT_MODIFICATION_FAIL, MESSAGE_PRIORITY_MED, e1ap_bearer_context_mod_failure_t, e1ap_bearer_modif_fail) /* E1AP Bearer Context Release Request: gNB-CU-CP -> gNB-CU-UP */ MESSAGE_DEF(E1AP_BEARER_CONTEXT_RELEASE_CMD, MESSAGE_PRIORITY_MED, e1ap_bearer_release_cmd_t, e1ap_bearer_release_cmd) /* E1AP Bearer Context Release Response: gNB-CU-UP -> gNB-CU-CP */ diff --git a/openair2/COMMON/e1ap_messages_types.h b/openair2/COMMON/e1ap_messages_types.h index adcff5e8cd..0709d8b00b 100644 --- a/openair2/COMMON/e1ap_messages_types.h +++ b/openair2/COMMON/e1ap_messages_types.h @@ -52,6 +52,7 @@ #define E1AP_BEARER_CONTEXT_SETUP_RESP(mSGpTR) (mSGpTR)->ittiMsg.e1ap_bearer_setup_resp #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_MODIFICATION_FAIL(mSGpTR) (mSGpTR)->ittiMsg.e1ap_bearer_modif_fail #define E1AP_BEARER_CONTEXT_RELEASE_CMD(mSGpTR) (mSGpTR)->ittiMsg.e1ap_bearer_release_cmd #define E1AP_BEARER_CONTEXT_RELEASE_CPLT(mSGpTR) (mSGpTR)->ittiMsg.e1ap_bearer_release_cplt #define E1AP_LOST_CONNECTION(mSGpTR) (mSGpTR)->ittiMsg.e1ap_lost_connection diff --git a/openair2/E1AP/e1ap.c b/openair2/E1AP/e1ap.c index f0e4d5578d..e8d901db52 100644 --- a/openair2/E1AP/e1ap.c +++ b/openair2/E1AP/e1ap.c @@ -57,7 +57,7 @@ const e1ap_message_processing_t e1ap_message_processing[E1AP_NUM_MSG_HANDLERS][3 e1apCUCP_handle_BEARER_CONTEXT_SETUP_FAILURE}, /* bearerContextSetup */ {e1apCUUP_handle_BEARER_CONTEXT_MODIFICATION_REQUEST, e1apCUCP_handle_BEARER_CONTEXT_MODIFICATION_RESPONSE, - 0}, /* bearerContextModification */ + e1apCUCP_handle_BEARER_CONTEXT_MODIFICATION_FAILURE}, /* bearerContextModification */ {0, 0, 0}, /* bearerContextModificationRequired */ {e1apCUUP_handle_BEARER_CONTEXT_RELEASE_COMMAND, e1apCUCP_handle_BEARER_CONTEXT_RELEASE_COMPLETE, 0}, /* bearerContextRelease */ {0, 0, 0}, /* bearerContextReleaseRequired */ @@ -439,10 +439,11 @@ static int e1apCUUP_send_BEARER_CONTEXT_MODIFICATION_RESPONSE(sctp_assoc_t assoc return e1ap_encode_send(UPtype, assoc_id, pdu, 0, __func__); } -int e1apCUUP_send_BEARER_CONTEXT_MODIFICATION_FAILURE(instance_t instance) +static int e1apCUUP_send_BEARER_CONTEXT_MODIFICATION_FAILURE(sctp_assoc_t assoc_id, const e1ap_bearer_context_mod_failure_t *out) { - AssertFatal(false, "Not implemented yet\n"); - return -1; + E1AP_E1AP_PDU_t *pdu = encode_E1_bearer_context_mod_failure(out); + e1ap_encode_send(UPtype, assoc_id, pdu, 0, __func__); + return 0; } /** @@ -478,13 +479,21 @@ int e1apCUCP_handle_BEARER_CONTEXT_MODIFICATION_RESPONSE(sctp_assoc_t assoc_id, return 0; } -int e1apCUCP_handle_BEARER_CONTEXT_MODIFICATION_FAILURE(instance_t instance, - sctp_assoc_t assoc_id, - uint32_t stream, - E1AP_E1AP_PDU_t *pdu) +int e1apCUCP_handle_BEARER_CONTEXT_MODIFICATION_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_mod_failure_t failure = {0}; + if (!decode_E1_bearer_context_mod_failure(&failure, pdu)) { + free_E1_bearer_context_mod_failure(&failure); + return -1; + } + LOG_E(E1AP, + "Received Bearer Context Modification Failure from CU-UP %d with cause value %d \n", + failure.gNB_cu_up_ue_id, + failure.cause.value); + MessageDef *msg = itti_alloc_new_message(TASK_CUUP_E1, 0, E1AP_BEARER_CONTEXT_MODIFICATION_FAIL); + E1AP_BEARER_CONTEXT_MODIFICATION_FAIL(msg) = cp_E1_bearer_context_mod_failure(&failure); + itti_send_msg_to_task(TASK_RRC_GNB, 0, msg); + return 0; } int e1apCUUP_send_BEARER_CONTEXT_MODIFICATION_REQUIRED(instance_t instance) @@ -1036,6 +1045,14 @@ void *E1AP_CUUP_task(void *arg) free_e1ap_context_mod_response(resp); } break; + case E1AP_BEARER_CONTEXT_MODIFICATION_FAIL: { + const e1ap_bearer_context_mod_failure_t *fail = &E1AP_BEARER_CONTEXT_MODIFICATION_FAIL(msg); + const e1ap_upcp_inst_t *inst = getCxtE1(myInstance); + AssertFatal(inst, "no E1 instance found for instance %ld\n", myInstance); + e1apCUUP_send_BEARER_CONTEXT_MODIFICATION_FAILURE(inst->cuup.assoc_id, fail); + free_E1_bearer_context_mod_failure(fail); + } break; + case E1AP_BEARER_CONTEXT_RELEASE_CPLT: { const e1ap_bearer_release_cplt_t *cplt = &E1AP_BEARER_CONTEXT_RELEASE_CPLT(msg); const e1ap_upcp_inst_t *inst = getCxtE1(myInstance); diff --git a/openair2/E1AP/e1ap.h b/openair2/E1AP/e1ap.h index b41559de09..66984f3b13 100644 --- a/openair2/E1AP/e1ap.h +++ b/openair2/E1AP/e1ap.h @@ -44,6 +44,8 @@ int e1apCUUP_handle_BEARER_CONTEXT_MODIFICATION_REQUEST(sctp_assoc_t assoc_id, e int e1apCUCP_handle_BEARER_CONTEXT_MODIFICATION_RESPONSE(sctp_assoc_t assoc_id, e1ap_upcp_inst_t *e1_inst, const E1AP_E1AP_PDU_t *pdu); +int e1apCUCP_handle_BEARER_CONTEXT_MODIFICATION_FAILURE(sctp_assoc_t assoc_id, e1ap_upcp_inst_t *inst, const E1AP_E1AP_PDU_t *pdu); + void e1apCUUP_send_BEARER_CONTEXT_SETUP_RESPONSE(sctp_assoc_t assoc_id, const e1ap_bearer_setup_resp_t *resp); int e1apCUUP_handle_BEARER_CONTEXT_RELEASE_COMMAND(sctp_assoc_t assoc_id, e1ap_upcp_inst_t *inst, const E1AP_E1AP_PDU_t *pdu); diff --git a/openair2/RRC/NR/rrc_gNB.c b/openair2/RRC/NR/rrc_gNB.c index a110e4af53..1c76eebccf 100644 --- a/openair2/RRC/NR/rrc_gNB.c +++ b/openair2/RRC/NR/rrc_gNB.c @@ -2570,6 +2570,23 @@ void rrc_gNB_process_e1_bearer_context_modif_resp(const e1ap_bearer_modif_resp_t } } +/** @brief E1AP Bearer Context Modification Failure processing on CU-CP */ +static void rrc_gNB_process_e1_bearer_context_modif_fail(const e1ap_bearer_context_mod_failure_t *fail) +{ + gNB_RRC_INST *rrc = RC.nrrrc[0]; + rrc_gNB_ue_context_t *ue_context_p = rrc_gNB_get_ue_context(rrc, fail->gNB_cu_cp_ue_id); + if (ue_context_p == NULL) { + LOG_E(NR_RRC, "No UE with CU-CP UE ID %d found (Bearer Context Modification Failure)\n", fail->gNB_cu_cp_ue_id); + return; + } + + LOG_W(NR_RRC, + "Bearer Context Modification Failure received for UE ID %d (CU-UP ID %d), cause: %d\n", + fail->gNB_cu_cp_ue_id, + fail->gNB_cu_up_ue_id, + fail->cause.value); +} + /** * @brief E1AP Bearer Context Release processing */ @@ -2869,6 +2886,10 @@ void *rrc_gnb_task(void *args_p) { free_e1ap_context_mod_response(&E1AP_BEARER_CONTEXT_MODIFICATION_RESP(msg_p)); break; + case E1AP_BEARER_CONTEXT_MODIFICATION_FAIL: + rrc_gNB_process_e1_bearer_context_modif_fail(&E1AP_BEARER_CONTEXT_MODIFICATION_FAIL(msg_p)); + break; + case E1AP_BEARER_CONTEXT_RELEASE_CPLT: rrc_gNB_process_e1_bearer_context_release_cplt(&E1AP_BEARER_CONTEXT_RELEASE_CPLT(msg_p)); break;