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; }