From 5c38a619ab37149f4c0beb046b7a491166300d1a Mon Sep 17 00:00:00 2001 From: Guido Casati Date: Thu, 6 Feb 2025 11:48:37 +0100 Subject: [PATCH 1/6] Use e1ap_cause_t in e1ap_bearer_release_cmd_t --- openair2/COMMON/e1ap_messages_types.h | 3 +-- openair2/E1AP/e1ap.c | 4 ++-- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/openair2/COMMON/e1ap_messages_types.h b/openair2/COMMON/e1ap_messages_types.h index 0cfeb7fd73..22d4855eeb 100644 --- a/openair2/COMMON/e1ap_messages_types.h +++ b/openair2/COMMON/e1ap_messages_types.h @@ -520,8 +520,7 @@ typedef struct e1ap_bearer_mod_req_s { typedef struct e1ap_bearer_release_cmd_s { uint32_t gNB_cu_cp_ue_id; uint32_t gNB_cu_up_ue_id; - long cause_type; - long cause; + e1ap_cause_t cause; } e1ap_bearer_release_cmd_t; typedef struct e1ap_bearer_release_cplt_s { diff --git a/openair2/E1AP/e1ap.c b/openair2/E1AP/e1ap.c index 42baaaa165..0cd64ca250 100644 --- a/openair2/E1AP/e1ap.c +++ b/openair2/E1AP/e1ap.c @@ -630,10 +630,10 @@ void extract_BEARER_CONTEXT_RELEASE_COMMAND(const E1AP_E1AP_PDU_t *pdu, e1ap_bea case E1AP_ProtocolIE_ID_id_Cause: DevAssert(ie->criticality == E1AP_Criticality_ignore); DevAssert(ie->value.present == E1AP_BearerContextReleaseCommandIEs__value_PR_Cause); - bearerCxt->cause_type = ie->value.choice.Cause.present; + bearerCxt->cause.type = ie->value.choice.Cause.present; if ((ie->value.choice.Cause.present != E1AP_Cause_PR_NOTHING) && (ie->value.choice.Cause.present != E1AP_Cause_PR_choice_extension)) - bearerCxt->cause = ie->value.choice.Cause.choice.radioNetwork; + bearerCxt->cause.value = ie->value.choice.Cause.choice.radioNetwork; break; default: From 3c8caeb9b2e8a3f6882f6785996ef254e0c9eb4a Mon Sep 17 00:00:00 2001 From: Guido Casati Date: Tue, 29 Apr 2025 16:57:24 +0200 Subject: [PATCH 2/6] Add Bearer Context Release Command enc/dec lib and unit test --- .../E1AP/lib/e1ap_bearer_context_management.c | 105 ++++++++++++++++++ .../E1AP/lib/e1ap_bearer_context_management.h | 6 + openair2/E1AP/tests/e1ap_lib_test.c | 42 +++++++ 3 files changed, 153 insertions(+) diff --git a/openair2/E1AP/lib/e1ap_bearer_context_management.c b/openair2/E1AP/lib/e1ap_bearer_context_management.c index be8b37ee45..01b1907034 100644 --- a/openair2/E1AP/lib/e1ap_bearer_context_management.c +++ b/openair2/E1AP/lib/e1ap_bearer_context_management.c @@ -1189,6 +1189,111 @@ void free_e1_bearer_context_setup_failure(const e1ap_bearer_context_setup_failur // do nothing } +/* =============================== + * E1AP Bearer Context Release + * =============================== */ + +/** @brief Bearer Context Release Command encoding (9.2.2.9, 3GPP TS 38.463) + * gNB-CU-CP → gNB-CU-UP */ +E1AP_E1AP_PDU_t *encode_e1_bearer_context_release_command(const e1ap_bearer_release_cmd_t *msg) +{ + E1AP_E1AP_PDU_t *pdu = calloc_or_fail(1, sizeof(*pdu)); + pdu->present = E1AP_E1AP_PDU_PR_initiatingMessage; + + // Type (M) + asn1cCalloc(pdu->choice.initiatingMessage, type); + type->procedureCode = E1AP_ProcedureCode_id_bearerContextRelease; + type->criticality = E1AP_Criticality_reject; + type->value.present = E1AP_InitiatingMessage__value_PR_BearerContextReleaseCommand; + E1AP_BearerContextReleaseCommand_t *out = &pdu->choice.initiatingMessage->value.choice.BearerContextReleaseCommand; + + // gNB-CU-CP UE E1AP ID (M) + asn1cSequenceAdd(out->protocolIEs.list, E1AP_BearerContextReleaseCommandIEs_t, ie1); + ie1->id = E1AP_ProtocolIE_ID_id_gNB_CU_CP_UE_E1AP_ID; + ie1->criticality = E1AP_Criticality_reject; + ie1->value.present = E1AP_BearerContextReleaseCommandIEs__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_BearerContextReleaseCommandIEs_t, ie2); + ie2->id = E1AP_ProtocolIE_ID_id_gNB_CU_UP_UE_E1AP_ID; + ie2->criticality = E1AP_Criticality_reject; + ie2->value.present = E1AP_BearerContextReleaseCommandIEs__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_BearerContextReleaseCommandIEs_t, ie3); + ie3->id = E1AP_ProtocolIE_ID_id_Cause; + ie3->criticality = E1AP_Criticality_reject; + ie3->value.present = E1AP_BearerContextReleaseCommandIEs__value_PR_Cause; + ie3->value.choice.Cause = e1_encode_cause_ie(&msg->cause); + + return pdu; +} + +/** @brief Bearer Context Release Command decoding (9.2.2.9, 3GPP TS 38.463) + * gNB-CU-CP → gNB-CU-UP */ +bool decode_e1_bearer_context_release_command(e1ap_bearer_release_cmd_t *out, const E1AP_E1AP_PDU_t *pdu) +{ + DevAssert(pdu != NULL); + _E1_EQ_CHECK_INT(pdu->present, E1AP_E1AP_PDU_PR_initiatingMessage); + E1AP_InitiatingMessage_t *type = pdu->choice.initiatingMessage; + _E1_EQ_CHECK_LONG(type->procedureCode, E1AP_ProcedureCode_id_bearerContextRelease); + _E1_EQ_CHECK_INT(type->value.present, E1AP_InitiatingMessage__value_PR_BearerContextReleaseCommand); + const E1AP_BearerContextReleaseCommand_t *in = &type->value.choice.BearerContextReleaseCommand; + + // Check mandatory IEs + E1AP_BearerContextReleaseCommandIEs_t *ie; + E1AP_LIB_FIND_IE(E1AP_BearerContextReleaseCommandIEs_t, ie, in, E1AP_ProtocolIE_ID_id_gNB_CU_CP_UE_E1AP_ID, true); + E1AP_LIB_FIND_IE(E1AP_BearerContextReleaseCommandIEs_t, ie, in, E1AP_ProtocolIE_ID_id_Cause, true); + E1AP_LIB_FIND_IE(E1AP_BearerContextReleaseCommandIEs_t, ie, in, E1AP_ProtocolIE_ID_id_gNB_CU_UP_UE_E1AP_ID, 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("%s decoding failure: IE %ld is invalid\n", __func__, ie->id) + return false; + break; + } + } + return true; +} + +/** @brief Bearer Context Release Command equality check */ +bool eq_bearer_context_release_command(const e1ap_bearer_release_cmd_t *a, const e1ap_bearer_release_cmd_t *b) +{ + _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 Bearer Context Release Command deep copy */ +e1ap_bearer_release_cmd_t cp_bearer_context_release_command(const e1ap_bearer_release_cmd_t *msg) +{ + // Shallow copy only + e1ap_bearer_release_cmd_t cp = *msg; + return cp; +} + +/** @brief Bearer Context Release Command equality check */ +void free_e1_bearer_context_release_command(const e1ap_bearer_release_cmd_t *msg) +{ + // 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 86c2ca0635..e847b3b74e 100644 --- a/openair2/E1AP/lib/e1ap_bearer_context_management.h +++ b/openair2/E1AP/lib/e1ap_bearer_context_management.h @@ -46,6 +46,12 @@ e1ap_bearer_context_setup_failure_t cp_bearer_context_setup_failure(const e1ap_b 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_release_command(const e1ap_bearer_release_cmd_t *msg); +bool decode_e1_bearer_context_release_command(e1ap_bearer_release_cmd_t *out, const struct E1AP_E1AP_PDU *pdu); +bool eq_bearer_context_release_command(const e1ap_bearer_release_cmd_t *a, const e1ap_bearer_release_cmd_t *b); +e1ap_bearer_release_cmd_t cp_bearer_context_release_command(const e1ap_bearer_release_cmd_t *msg); +void free_e1_bearer_context_release_command(const e1ap_bearer_release_cmd_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 bae85684de..d91c81abec 100644 --- a/openair2/E1AP/tests/e1ap_lib_test.c +++ b/openair2/E1AP/tests/e1ap_lib_test.c @@ -265,6 +265,46 @@ static void test_bearer_context_setup_failure(void) free_e1_bearer_context_setup_failure(&cp); } +/** @brief Test E1AP Bearer Context Release Command encoding/decoding */ +static void test_bearer_context_release_command(void) +{ + e1ap_bearer_release_cmd_t orig = { + .gNB_cu_cp_ue_id = 0x1234, + .gNB_cu_up_ue_id = 0x5678, + .cause.type = E1AP_CAUSE_RADIO_NETWORK, + .cause.value = E1AP_RADIO_CAUSE_MULTIPLE_QOS_FLOW_ID_INSTANCES, + }; + + // Encode the original message + E1AP_E1AP_PDU_t *enc = encode_e1_bearer_context_release_command(&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_release_cmd_t decoded = {0}; + AssertFatal(decode_e1_bearer_context_release_command(&decoded, dec), "decode_e1_bearer_context_release_command failed"); + + // Free the E1AP decoded message + e1ap_msg_free(dec); + + // Equality check original/decoded + AssertFatal(eq_bearer_context_release_command(&orig, &decoded), "eq_bearer_context_release_command: decoded message does not match original"); + + // Free the memory for the decoded message + free_e1_bearer_context_release_command(&decoded); + + // Deep copy and equality check of the original message + e1ap_bearer_release_cmd_t cp = cp_bearer_context_release_command(&orig); + AssertFatal(eq_bearer_context_release_command(&orig, &cp), "eq_bearer_context_release_command(): copied message doesn't match\n"); + + // Cleanup + free_e1_bearer_context_release_command(&orig); + free_e1_bearer_context_release_command(&cp); +} /** * @brief Test CU-UP Setup Request encoding/decoding @@ -675,5 +715,7 @@ int main() test_bearer_context_modification_request(); test_bearer_context_modification_response(); test_bearer_context_modification_response_fail(); + // Bearer Context Release + test_bearer_context_release_command(); return 0; } From f8eba806da1f46c26548b7741e2bc7d5b6cc30df Mon Sep 17 00:00:00 2001 From: Guido Casati Date: Thu, 6 Feb 2025 12:05:30 +0100 Subject: [PATCH 3/6] Use Bearer Context Release Command enc/dec lib in stack --- openair2/E1AP/e1ap.c | 88 +++++--------------------------------------- 1 file changed, 10 insertions(+), 78 deletions(-) diff --git a/openair2/E1AP/e1ap.c b/openair2/E1AP/e1ap.c index 0cd64ca250..5562c8e161 100644 --- a/openair2/E1AP/e1ap.c +++ b/openair2/E1AP/e1ap.c @@ -532,37 +532,10 @@ int e1apCUUP_handle_BEARER_CONTEXT_MODIFICATION_CONFIRM(instance_t instance, BEARER CONTEXT RELEASE */ -static int fill_BEARER_CONTEXT_RELEASE_COMMAND(e1ap_bearer_release_cmd_t *const cmd, E1AP_E1AP_PDU_t *pdu) +static int e1apCUCP_send_BEARER_CONTEXT_RELEASE_COMMAND(sctp_assoc_t assoc_id, e1ap_bearer_release_cmd_t *const cmd) { - pdu->present = E1AP_E1AP_PDU_PR_initiatingMessage; - asn1cCalloc(pdu->choice.initiatingMessage, msg); - msg->procedureCode = E1AP_ProcedureCode_id_bearerContextRelease; - msg->criticality = E1AP_Criticality_reject; - msg->value.present = E1AP_InitiatingMessage__value_PR_BearerContextReleaseCommand; - E1AP_BearerContextReleaseCommand_t *out = &pdu->choice.initiatingMessage->value.choice.BearerContextReleaseCommand; - /* mandatory */ - /* c1. gNB-CU-CP UE E1AP ID */ - asn1cSequenceAdd(out->protocolIEs.list, E1AP_BearerContextReleaseCommandIEs_t, ieC1); - ieC1->id = E1AP_ProtocolIE_ID_id_gNB_CU_CP_UE_E1AP_ID; - ieC1->criticality = E1AP_Criticality_reject; - ieC1->value.present = E1AP_BearerContextReleaseCommandIEs__value_PR_GNB_CU_CP_UE_E1AP_ID; - ieC1->value.choice.GNB_CU_CP_UE_E1AP_ID = cmd->gNB_cu_cp_ue_id; - /* mandatory */ - /* c2. gNB-CU-UP UE E1AP ID */ - asn1cSequenceAdd(out->protocolIEs.list, E1AP_BearerContextReleaseCommandIEs_t, ieC2); - ieC2->id = E1AP_ProtocolIE_ID_id_gNB_CU_UP_UE_E1AP_ID; - ieC2->criticality = E1AP_Criticality_reject; - ieC2->value.present = E1AP_BearerContextReleaseCommandIEs__value_PR_GNB_CU_UP_UE_E1AP_ID; - ieC2->value.choice.GNB_CU_UP_UE_E1AP_ID = cmd->gNB_cu_cp_ue_id; - - return 0; -} - -int e1apCUCP_send_BEARER_CONTEXT_RELEASE_COMMAND(sctp_assoc_t assoc_id, e1ap_bearer_release_cmd_t *const cmd) -{ - E1AP_E1AP_PDU_t pdu = {0}; - fill_BEARER_CONTEXT_RELEASE_COMMAND(cmd, &pdu); - return e1ap_encode_send(CPtype, assoc_id, &pdu, 0, __func__); + E1AP_E1AP_PDU_t *pdu = encode_e1_bearer_context_release_command(cmd); + return e1ap_encode_send(CPtype, assoc_id, pdu, 0, __func__); } static int fill_BEARER_CONTEXT_RELEASE_COMPLETE(const e1ap_bearer_release_cplt_t *cplt, E1AP_E1AP_PDU_t *pdu) @@ -604,56 +577,14 @@ int e1apCUUP_send_BEARER_CONTEXT_RELEASE_REQUEST(instance_t instance) return -1; } -void extract_BEARER_CONTEXT_RELEASE_COMMAND(const E1AP_E1AP_PDU_t *pdu, e1ap_bearer_release_cmd_t *bearerCxt) +int e1apCUUP_handle_BEARER_CONTEXT_RELEASE_COMMAND(sctp_assoc_t assoc_id, e1ap_upcp_inst_t *inst, const E1AP_E1AP_PDU_t *pdu) { - const E1AP_BearerContextReleaseCommand_t *in = &pdu->choice.initiatingMessage->value.choice.BearerContextReleaseCommand; - E1AP_BearerContextReleaseCommandIEs_t *ie; - - LOG_D(E1AP, "Bearer context setup number of IEs %d\n", in->protocolIEs.list.count); - - for (int i = 0; i < in->protocolIEs.list.count; i++) { - ie = in->protocolIEs.list.array[i]; - - switch(ie->id) { - case E1AP_ProtocolIE_ID_id_gNB_CU_CP_UE_E1AP_ID: - DevAssert(ie->criticality == E1AP_Criticality_reject); - DevAssert(ie->value.present == E1AP_BearerContextReleaseCommandIEs__value_PR_GNB_CU_CP_UE_E1AP_ID); - bearerCxt->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: - DevAssert(ie->criticality == E1AP_Criticality_reject); - DevAssert(ie->value.present == E1AP_BearerContextReleaseCommandIEs__value_PR_GNB_CU_UP_UE_E1AP_ID); - bearerCxt->gNB_cu_up_ue_id = ie->value.choice.GNB_CU_UP_UE_E1AP_ID; - break; - - case E1AP_ProtocolIE_ID_id_Cause: - DevAssert(ie->criticality == E1AP_Criticality_ignore); - DevAssert(ie->value.present == E1AP_BearerContextReleaseCommandIEs__value_PR_Cause); - bearerCxt->cause.type = ie->value.choice.Cause.present; - if ((ie->value.choice.Cause.present != E1AP_Cause_PR_NOTHING) && - (ie->value.choice.Cause.present != E1AP_Cause_PR_choice_extension)) - bearerCxt->cause.value = ie->value.choice.Cause.choice.radioNetwork; - break; - - default: - LOG_E(E1AP, "Handle for this IE is not implemented (or) invalid IE detected\n"); - break; - } + e1ap_bearer_release_cmd_t release = {0}; + if(!decode_e1_bearer_context_release_command(&release, pdu)) { + free_e1_bearer_context_release_command(&release); + return -1; } -} - -int e1apCUUP_handle_BEARER_CONTEXT_RELEASE_COMMAND(sctp_assoc_t assoc_id, e1ap_upcp_inst_t *e1_inst, const E1AP_E1AP_PDU_t *pdu) -{ - DevAssert(pdu != NULL); - DevAssert(pdu->present == E1AP_E1AP_PDU_PR_initiatingMessage); - DevAssert(pdu->choice.initiatingMessage->procedureCode == E1AP_ProcedureCode_id_bearerContextRelease); - DevAssert(pdu->choice.initiatingMessage->criticality == E1AP_Criticality_reject); - DevAssert(pdu->choice.initiatingMessage->value.present == E1AP_InitiatingMessage__value_PR_BearerContextReleaseCommand); - - e1ap_bearer_release_cmd_t bearerCxt = {0}; - extract_BEARER_CONTEXT_RELEASE_COMMAND(pdu, &bearerCxt); - e1_bearer_release_cmd(&bearerCxt); + e1_bearer_release_cmd(&release); return 0; } @@ -974,6 +905,7 @@ void *E1AP_CUCP_task(void *arg) case E1AP_BEARER_CONTEXT_RELEASE_CMD: e1apCUCP_send_BEARER_CONTEXT_RELEASE_COMMAND(assoc_id, &E1AP_BEARER_CONTEXT_RELEASE_CMD(msg)); + free_e1_bearer_context_release_command(&E1AP_BEARER_CONTEXT_RELEASE_CMD(msg)); break; default: From 8f9761ac84998c77faa65d2219e05b3006ecb76e Mon Sep 17 00:00:00 2001 From: Guido Casati Date: Thu, 6 Feb 2025 12:26:59 +0100 Subject: [PATCH 4/6] Add Bearer Context Release Complete enc/dec lib and unit test --- .../E1AP/lib/e1ap_bearer_context_management.c | 87 +++++++++++++++++++ .../E1AP/lib/e1ap_bearer_context_management.h | 6 ++ openair2/E1AP/tests/e1ap_lib_test.c | 40 +++++++++ 3 files changed, 133 insertions(+) diff --git a/openair2/E1AP/lib/e1ap_bearer_context_management.c b/openair2/E1AP/lib/e1ap_bearer_context_management.c index 01b1907034..45cca18c0f 100644 --- a/openair2/E1AP/lib/e1ap_bearer_context_management.c +++ b/openair2/E1AP/lib/e1ap_bearer_context_management.c @@ -1294,6 +1294,93 @@ void free_e1_bearer_context_release_command(const e1ap_bearer_release_cmd_t *msg // do nothing } +/** + * @brief Bearer Context Release Complete encoding (9.2.2.10, 3GPP TS 38.463) + * gNB-CU-UP → gNB-CU-CP + */ +E1AP_E1AP_PDU_t *encode_e1_bearer_context_release_complete(const e1ap_bearer_release_cplt_t *cplt) +{ + E1AP_E1AP_PDU_t *pdu = calloc_or_fail(1, sizeof(*pdu)); + pdu->present = E1AP_E1AP_PDU_PR_successfulOutcome; + // Message Type (M) + asn1cCalloc(pdu->choice.successfulOutcome, msg); + msg->procedureCode = E1AP_ProcedureCode_id_bearerContextRelease; + msg->criticality = E1AP_Criticality_reject; + msg->value.present = E1AP_SuccessfulOutcome__value_PR_BearerContextReleaseComplete; + + E1AP_BearerContextReleaseComplete_t *out = &msg->value.choice.BearerContextReleaseComplete; + // gNB-CU-CP UE E1AP ID (M) + asn1cSequenceAdd(out->protocolIEs.list, E1AP_BearerContextReleaseCompleteIEs_t, ie1); + ie1->id = E1AP_ProtocolIE_ID_id_gNB_CU_CP_UE_E1AP_ID; + ie1->criticality = E1AP_Criticality_reject; + ie1->value.present = E1AP_BearerContextReleaseCompleteIEs__value_PR_GNB_CU_CP_UE_E1AP_ID; + ie1->value.choice.GNB_CU_CP_UE_E1AP_ID = cplt->gNB_cu_cp_ue_id; + // gNB-CU-UP UE E1AP ID (M) + asn1cSequenceAdd(out->protocolIEs.list, E1AP_BearerContextReleaseCompleteIEs_t, ie2); + ie2->id = E1AP_ProtocolIE_ID_id_gNB_CU_UP_UE_E1AP_ID; + ie2->criticality = E1AP_Criticality_reject; + ie2->value.present = E1AP_BearerContextReleaseCompleteIEs__value_PR_GNB_CU_UP_UE_E1AP_ID; + ie2->value.choice.GNB_CU_UP_UE_E1AP_ID = cplt->gNB_cu_up_ue_id; + return pdu; +} + +/** + * @brief Bearer Context Release Complete decoding (9.2.2.10, 3GPP TS 38.463) + * gNB-CU-UP → gNB-CU-CP + */ +bool decode_e1_bearer_context_release_complete(e1ap_bearer_release_cplt_t *out, const E1AP_E1AP_PDU_t *pdu) +{ + DevAssert(pdu != NULL); + _E1_EQ_CHECK_INT(pdu->present, E1AP_E1AP_PDU_PR_successfulOutcome); + E1AP_SuccessfulOutcome_t *type = pdu->choice.successfulOutcome; + _E1_EQ_CHECK_LONG(type->procedureCode, E1AP_ProcedureCode_id_bearerContextRelease); + _E1_EQ_CHECK_INT(type->value.present, E1AP_SuccessfulOutcome__value_PR_BearerContextReleaseComplete); + const E1AP_BearerContextReleaseComplete_t *in = &type->value.choice.BearerContextReleaseComplete; + + // Check mandatory IEs + E1AP_BearerContextReleaseCompleteIEs_t *ie; + E1AP_LIB_FIND_IE(E1AP_BearerContextReleaseCompleteIEs_t, ie, in, E1AP_ProtocolIE_ID_id_gNB_CU_CP_UE_E1AP_ID, true); + E1AP_LIB_FIND_IE(E1AP_BearerContextReleaseCompleteIEs_t, ie, in, E1AP_ProtocolIE_ID_id_gNB_CU_UP_UE_E1AP_ID, 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; + default: + PRINT_ERROR("%s decoding failure: IE %ld is not handled or invalid\n", __func__, ie->id) + break; + } + } + return true; +} + +/** @brief Bearer Context Release Complete equality check */ +bool eq_bearer_context_release_complete(const e1ap_bearer_release_cplt_t *a, const e1ap_bearer_release_cplt_t *b) +{ + _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); + return true; +} + +/** @brief Bearer Context Release Complete deep copy */ +e1ap_bearer_release_cplt_t cp_bearer_context_release_complete(const e1ap_bearer_release_cplt_t *src) +{ + e1ap_bearer_release_cplt_t dst = *src; + return dst; +} + +/** @brief Bearer Context Release Complete equality check */ +void free_e1_bearer_context_release_complete(const e1ap_bearer_release_cplt_t *msg) +{ + // No dynamic memory, 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 e847b3b74e..bf3d8edb1d 100644 --- a/openair2/E1AP/lib/e1ap_bearer_context_management.h +++ b/openair2/E1AP/lib/e1ap_bearer_context_management.h @@ -52,6 +52,12 @@ bool eq_bearer_context_release_command(const e1ap_bearer_release_cmd_t *a, const e1ap_bearer_release_cmd_t cp_bearer_context_release_command(const e1ap_bearer_release_cmd_t *msg); void free_e1_bearer_context_release_command(const e1ap_bearer_release_cmd_t *msg); +struct E1AP_E1AP_PDU *encode_e1_bearer_context_release_complete(const e1ap_bearer_release_cplt_t *cplt); +bool decode_e1_bearer_context_release_complete(e1ap_bearer_release_cplt_t *out, const struct E1AP_E1AP_PDU *pdu); +bool eq_bearer_context_release_complete(const e1ap_bearer_release_cplt_t *a, const e1ap_bearer_release_cplt_t *b); +e1ap_bearer_release_cplt_t cp_bearer_context_release_complete(const e1ap_bearer_release_cplt_t *src); +void free_e1_bearer_context_release_complete(const e1ap_bearer_release_cplt_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 d91c81abec..cd218a9a13 100644 --- a/openair2/E1AP/tests/e1ap_lib_test.c +++ b/openair2/E1AP/tests/e1ap_lib_test.c @@ -306,6 +306,45 @@ static void test_bearer_context_release_command(void) free_e1_bearer_context_release_command(&cp); } +/** @brief Test E1AP Bearer Context Release Complete encoding/decoding */ +static void test_bearer_context_release_complete(void) +{ + e1ap_bearer_release_cplt_t orig = { + .gNB_cu_cp_ue_id = 0x1234, + .gNB_cu_up_ue_id = 0x5678, + }; + + // Encode the original message + E1AP_E1AP_PDU_t *enc = encode_e1_bearer_context_release_complete(&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_release_cplt_t decoded = {0}; + AssertFatal(decode_e1_bearer_context_release_complete(&decoded, dec), "decode_e1_bearer_context_release_complete failed"); + + // Free the E1AP decoded message + e1ap_msg_free(dec); + + // Equality check original/decoded + AssertFatal(eq_bearer_context_release_complete(&orig, &decoded), "eq_bearer_context_release_complete: decoded message does not match original"); + + // Free the memory for the decoded message + free_e1_bearer_context_release_complete(&decoded); + + // Deep copy and equality check of the original message + e1ap_bearer_release_cplt_t cp = cp_bearer_context_release_complete(&orig); + AssertFatal(eq_bearer_context_release_complete(&orig, &cp), "eq_bearer_context_release_complete(): copied message doesn't match\n"); + + // Cleanup + free_e1_bearer_context_release_complete(&orig); + free_e1_bearer_context_release_complete(&cp); +} + /** * @brief Test CU-UP Setup Request encoding/decoding */ @@ -717,5 +756,6 @@ int main() test_bearer_context_modification_response_fail(); // Bearer Context Release test_bearer_context_release_command(); + test_bearer_context_release_complete(); return 0; } From 67ec7d31740b2d2e65245c98fa12e33bc2730a10 Mon Sep 17 00:00:00 2001 From: Guido Casati Date: Thu, 6 Feb 2025 12:31:43 +0100 Subject: [PATCH 5/6] Use Bearer Context Release Complete enc/dec lib in stack --- openair2/E1AP/e1ap.c | 74 +++++--------------------------------------- 1 file changed, 7 insertions(+), 67 deletions(-) diff --git a/openair2/E1AP/e1ap.c b/openair2/E1AP/e1ap.c index 5562c8e161..149b5e6740 100644 --- a/openair2/E1AP/e1ap.c +++ b/openair2/E1AP/e1ap.c @@ -538,37 +538,10 @@ static int e1apCUCP_send_BEARER_CONTEXT_RELEASE_COMMAND(sctp_assoc_t assoc_id, e return e1ap_encode_send(CPtype, assoc_id, pdu, 0, __func__); } -static int fill_BEARER_CONTEXT_RELEASE_COMPLETE(const e1ap_bearer_release_cplt_t *cplt, E1AP_E1AP_PDU_t *pdu) -{ - pdu->present = E1AP_E1AP_PDU_PR_successfulOutcome; - asn1cCalloc(pdu->choice.successfulOutcome, msg); - msg->procedureCode = E1AP_ProcedureCode_id_bearerContextRelease; - msg->criticality = E1AP_Criticality_reject; - msg->value.present = E1AP_SuccessfulOutcome__value_PR_BearerContextReleaseComplete; - E1AP_BearerContextReleaseComplete_t *out = &pdu->choice.successfulOutcome->value.choice.BearerContextReleaseComplete; - /* mandatory */ - /* c1. gNB-CU-CP UE E1AP ID */ - asn1cSequenceAdd(out->protocolIEs.list, E1AP_BearerContextReleaseCompleteIEs_t, ieC1); - ieC1->id = E1AP_ProtocolIE_ID_id_gNB_CU_CP_UE_E1AP_ID; - ieC1->criticality = E1AP_Criticality_reject; - ieC1->value.present = E1AP_BearerContextReleaseCompleteIEs__value_PR_GNB_CU_CP_UE_E1AP_ID; - ieC1->value.choice.GNB_CU_CP_UE_E1AP_ID = cplt->gNB_cu_cp_ue_id; - /* mandatory */ - /* c2. gNB-CU-UP UE E1AP ID */ - asn1cSequenceAdd(out->protocolIEs.list, E1AP_BearerContextReleaseCompleteIEs_t, ieC2); - ieC2->id = E1AP_ProtocolIE_ID_id_gNB_CU_UP_UE_E1AP_ID; - ieC2->criticality = E1AP_Criticality_reject; - ieC2->value.present = E1AP_BearerContextReleaseCompleteIEs__value_PR_GNB_CU_UP_UE_E1AP_ID; - ieC2->value.choice.GNB_CU_UP_UE_E1AP_ID = cplt->gNB_cu_cp_ue_id; - - return 0; -} - int e1apCUUP_send_BEARER_CONTEXT_RELEASE_COMPLETE(sctp_assoc_t assoc_id, const e1ap_bearer_release_cplt_t *cplt) { - E1AP_E1AP_PDU_t pdu = {0}; - fill_BEARER_CONTEXT_RELEASE_COMPLETE(cplt, &pdu); - return e1ap_encode_send(CPtype, assoc_id, &pdu, 0, __func__); + E1AP_E1AP_PDU_t *pdu = encode_e1_bearer_context_release_complete(cplt); + return e1ap_encode_send(CPtype, assoc_id, pdu, 0, __func__); } int e1apCUUP_send_BEARER_CONTEXT_RELEASE_REQUEST(instance_t instance) @@ -588,49 +561,16 @@ int e1apCUUP_handle_BEARER_CONTEXT_RELEASE_COMMAND(sctp_assoc_t assoc_id, e1ap_u return 0; } -void extract_BEARER_CONTEXT_RELEASE_COMPLETE(const E1AP_E1AP_PDU_t *pdu, e1ap_bearer_release_cplt_t *bearerCxt) -{ - const E1AP_BearerContextReleaseComplete_t *in = &pdu->choice.successfulOutcome->value.choice.BearerContextReleaseComplete; - E1AP_BearerContextReleaseCompleteIEs_t *ie; - - LOG_D(E1AP, "Bearer context setup number of IEs %d\n", in->protocolIEs.list.count); - - for (int i = 0; i < in->protocolIEs.list.count; i++) { - ie = in->protocolIEs.list.array[i]; - - switch(ie->id) { - case E1AP_ProtocolIE_ID_id_gNB_CU_CP_UE_E1AP_ID: - DevAssert(ie->criticality == E1AP_Criticality_reject); - DevAssert(ie->value.present == E1AP_BearerContextReleaseCompleteIEs__value_PR_GNB_CU_CP_UE_E1AP_ID); - bearerCxt->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: - DevAssert(ie->criticality == E1AP_Criticality_reject); - DevAssert(ie->value.present == E1AP_BearerContextReleaseCompleteIEs__value_PR_GNB_CU_UP_UE_E1AP_ID); - bearerCxt->gNB_cu_up_ue_id = ie->value.choice.GNB_CU_UP_UE_E1AP_ID; - break; - - default: - LOG_E(E1AP, "Handle for this IE is not implemented (or) invalid IE detected\n"); - break; - } - } -} - int e1apCUCP_handle_BEARER_CONTEXT_RELEASE_COMPLETE(sctp_assoc_t assoc_id, e1ap_upcp_inst_t *e1_inst, const E1AP_E1AP_PDU_t *pdu) { - DevAssert(pdu != NULL); - DevAssert(pdu->present == E1AP_E1AP_PDU_PR_successfulOutcome); - DevAssert(pdu->choice.successfulOutcome->procedureCode == E1AP_ProcedureCode_id_bearerContextRelease); - DevAssert(pdu->choice.successfulOutcome->criticality == E1AP_Criticality_reject); - DevAssert(pdu->choice.successfulOutcome->value.present == E1AP_SuccessfulOutcome__value_PR_BearerContextReleaseComplete); - e1ap_bearer_release_cplt_t bearerCxt = {0}; - extract_BEARER_CONTEXT_RELEASE_COMPLETE(pdu, &bearerCxt); + if(!decode_e1_bearer_context_release_complete(&bearerCxt, pdu)) { + free_e1_bearer_context_release_complete(&bearerCxt); + return -1; + } MessageDef *msg = itti_alloc_new_message(TASK_CUUP_E1, 0, E1AP_BEARER_CONTEXT_RELEASE_CPLT); e1ap_bearer_release_cplt_t *cplt = &E1AP_BEARER_CONTEXT_RELEASE_CPLT(msg); - *cplt = bearerCxt; + *cplt = cp_bearer_context_release_complete(&bearerCxt); itti_send_msg_to_task(TASK_RRC_GNB, 0, msg); return 0; } From 66d32fb39b2fe79d2235d71a5cfc1abac4a66ca9 Mon Sep 17 00:00:00 2001 From: Guido Casati Date: Mon, 5 May 2025 10:48:17 +0200 Subject: [PATCH 6/6] Add cause to Bearer Context Release message trigger --- openair2/RRC/NR/rrc_gNB_NGAP.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/openair2/RRC/NR/rrc_gNB_NGAP.c b/openair2/RRC/NR/rrc_gNB_NGAP.c index fadbea4825..6d0264152a 100644 --- a/openair2/RRC/NR/rrc_gNB_NGAP.c +++ b/openair2/RRC/NR/rrc_gNB_NGAP.c @@ -1274,9 +1274,11 @@ int rrc_gNB_process_NGAP_UE_CONTEXT_RELEASE_COMMAND(MessageDef *msg_p, instance_ * session (intentionally, or because of erros) */ if (ue_associated_to_cuup(rrc, UE)) { sctp_assoc_t assoc_id = get_existing_cuup_for_ue(rrc, UE); + e1ap_cause_t cause = {.type = E1AP_CAUSE_RADIO_NETWORK, .value = E1AP_RADIO_CAUSE_NORMAL_RELEASE}; e1ap_bearer_release_cmd_t cmd = { .gNB_cu_cp_ue_id = UE->rrc_ue_id, .gNB_cu_up_ue_id = UE->rrc_ue_id, + .cause = cause, }; rrc->cucp_cuup.bearer_context_release(assoc_id, &cmd); }