diff --git a/lib/core/ogs-3gpp-types.c b/lib/core/ogs-3gpp-types.c index 6cfec3339f..4e82003f21 100644 --- a/lib/core/ogs-3gpp-types.c +++ b/lib/core/ogs-3gpp-types.c @@ -669,6 +669,26 @@ ogs_slice_data_t *ogs_slice_find_by_s_nssai( return NULL; } +ogs_slice_data_t *ogs_slice_find_by_dnn( + ogs_slice_data_t *slice_data, int num_of_slice_data, char *dnn) +{ + int i, j; + + ogs_assert(slice_data); + ogs_assert(num_of_slice_data); + ogs_assert(dnn); + + /* Compare DNN */ + for (i = 0; i < num_of_slice_data; i++) { + for (j = 0; j < slice_data[i].num_of_session; j++) { + if (strcmp(slice_data[i].session[j].name, dnn) == 0) + return slice_data + i; + } + } + + return NULL; +} + void ogs_subscription_data_free(ogs_subscription_data_t *subscription_data) { int i, j; diff --git a/lib/core/ogs-3gpp-types.h b/lib/core/ogs-3gpp-types.h index 5a6c546310..fc5c0177f2 100644 --- a/lib/core/ogs-3gpp-types.h +++ b/lib/core/ogs-3gpp-types.h @@ -653,6 +653,8 @@ typedef struct ogs_slice_data_s { ogs_slice_data_t *ogs_slice_find_by_s_nssai( ogs_slice_data_t *slice_data, int num_of_slice_data, ogs_s_nssai_t *s_nssai); +ogs_slice_data_t *ogs_slice_find_by_dnn( + ogs_slice_data_t *slice_data, int num_of_slice_data, char *dnn); typedef struct ogs_subscription_data_s { #define OGS_ACCESS_RESTRICTION_UTRAN_NOT_ALLOWED (1) diff --git a/src/amf/gmm-handler.c b/src/amf/gmm-handler.c index 55ac03eaef..a20eb91fef 100644 --- a/src/amf/gmm-handler.c +++ b/src/amf/gmm-handler.c @@ -1001,6 +1001,19 @@ int gmm_handle_ul_nas_transport(amf_ue_t *amf_ue, } } + if (ul_nas_transport->presencemask & + OGS_NAS_5GS_UL_NAS_TRANSPORT_DNN_PRESENT) { + if (sess->dnn) + ogs_free(sess->dnn); + sess->dnn = ogs_strdup(dnn->value); + ogs_assert(sess->dnn); + + if (!selected_slice) { + selected_slice = ogs_slice_find_by_dnn( + amf_ue->slice, amf_ue->num_of_slice, sess->dnn); + } + } + if (!selected_slice) { int i; for (i = 0; i < amf_ue->num_of_slice; i++) { @@ -1022,14 +1035,6 @@ int gmm_handle_ul_nas_transport(amf_ue_t *amf_ue, sess->s_nssai.sst = selected_slice->s_nssai.sst; sess->s_nssai.sd.v = selected_slice->s_nssai.sd.v; - if (ul_nas_transport->presencemask & - OGS_NAS_5GS_UL_NAS_TRANSPORT_DNN_PRESENT) { - if (sess->dnn) - ogs_free(sess->dnn); - sess->dnn = ogs_strdup(dnn->value); - ogs_assert(sess->dnn); - } - if (!sess->dnn) { if (selected_slice->num_of_session) { sess->dnn = ogs_strdup(selected_slice->session[0].name); @@ -1047,7 +1052,6 @@ int gmm_handle_ul_nas_transport(amf_ue_t *amf_ue, ogs_info("UE SUPI[%s] DNN[%s] S_NSSAI[SST:%d SD:0x%x]", amf_ue->supi, sess->dnn, sess->s_nssai.sst, sess->s_nssai.sd.v); - if (!SESSION_CONTEXT_IN_SMF(sess)) { ogs_sbi_nf_instance_t *nf_instance = NULL; diff --git a/tests/common/context.c b/tests/common/context.c index c1b326a06c..1a426d78ce 100644 --- a/tests/common/context.c +++ b/tests/common/context.c @@ -1717,7 +1717,7 @@ bson_t *test_db_new_ims(test_ue_t *test_ue) return doc; } -bson_t *test_db_new_slice(test_ue_t *test_ue) +bson_t *test_db_new_slice_with_same_dnn(test_ue_t *test_ue) { bson_t *doc = NULL; @@ -2090,6 +2090,379 @@ bson_t *test_db_new_slice(test_ue_t *test_ue) return doc; } +bson_t *test_db_new_slice_with_different_dnn(test_ue_t *test_ue) +{ + bson_t *doc = NULL; + + ogs_assert(test_ue); + + doc = BCON_NEW( + "imsi", BCON_UTF8(test_ue->imsi), + "ambr", "{", + "downlink", "{", + "value", BCON_INT32(1), + "unit", BCON_INT32(3), + "}", + "uplink", "{", + "value", BCON_INT32(1), + "unit", BCON_INT32(3), + "}", + "}", + "slice", "[", + "{", + "sst", BCON_INT32(1), + "default_indicator", BCON_BOOL(true), + "session", "[", + "{", + "name", BCON_UTF8("internet"), + "type", BCON_INT32(3), + "ambr", "{", + "downlink", "{", + "value", BCON_INT32(1), + "unit", BCON_INT32(3), + "}", + "uplink", "{", + "value", BCON_INT32(1), + "unit", BCON_INT32(3), + "}", + "}", + "qos", "{", + "index", BCON_INT32(9), + "arp", "{", + "priority_level", BCON_INT32(8), + "pre_emption_vulnerability", BCON_INT32(1), + "pre_emption_capability", BCON_INT32(1), + "}", + "}", + "}", + "{", + "name", BCON_UTF8("ims"), + "type", BCON_INT32(3), + "ambr", "{", + "downlink", "{", + "value", BCON_INT32(1), + "unit", BCON_INT32(3), + "}", + "uplink", "{", + "value", BCON_INT32(1), + "unit", BCON_INT32(3), + "}", + "}", + "qos", "{", + "index", BCON_INT32(5), + "arp", "{", + "priority_level", BCON_INT32(1), + "pre_emption_vulnerability", BCON_INT32(1), + "pre_emption_capability", BCON_INT32(1), + "}", + "}", + "pcc_rule", "[", + "{", + "qos", "{", + "index", BCON_INT32(1), + "arp", "{", + "priority_level", BCON_INT32(3), + "pre_emption_vulnerability", BCON_INT32(2), + "pre_emption_capability", BCON_INT32(2), + "}", + "mbr", "{", + "downlink", "{", + "value", BCON_INT32(82), + "unit", BCON_INT32(1), + "}", + "uplink", "{", + "value", BCON_INT32(82), + "unit", BCON_INT32(1), + "}", + "}", + "gbr", "{", + "downlink", "{", + "value", BCON_INT32(82), + "unit", BCON_INT32(1), + "}", + "uplink", "{", + "value", BCON_INT32(82), + "unit", BCON_INT32(1), + "}", + "}", + "}", + "}", + "{", + "qos", "{", + "index", BCON_INT32(2), + "arp", "{", + "priority_level", BCON_INT32(4), + "pre_emption_vulnerability", BCON_INT32(2), + "pre_emption_capability", BCON_INT32(2), + "}", + "mbr", "{", + "downlink", "{", + "value", BCON_INT32(802), + "unit", BCON_INT32(1), + "}", + "uplink", "{", + "value", BCON_INT32(802), + "unit", BCON_INT32(1), + "}", + "}", + "gbr", "{", + "downlink", "{", + "value", BCON_INT32(802), + "unit", BCON_INT32(1), + "}", + "uplink", "{", + "value", BCON_INT32(802), + "unit", BCON_INT32(1), + "}", + "}", + "}", + "}", + "]", + "}", + "]", + "}", + "{", + "sst", BCON_INT32(1), + "sd", BCON_UTF8("000080"), + "session", "[", + "{", + "name", BCON_UTF8("internet2"), + "type", BCON_INT32(3), + "ambr", "{", + "downlink", "{", + "value", BCON_INT32(1), + "unit", BCON_INT32(3), + "}", + "uplink", "{", + "value", BCON_INT32(1), + "unit", BCON_INT32(3), + "}", + "}", + "qos", "{", + "index", BCON_INT32(9), + "arp", "{", + "priority_level", BCON_INT32(8), + "pre_emption_vulnerability", BCON_INT32(1), + "pre_emption_capability", BCON_INT32(1), + "}", + "}", + "}", + "{", + "name", BCON_UTF8("ims2"), + "type", BCON_INT32(3), + "ambr", "{", + "downlink", "{", + "value", BCON_INT32(1), + "unit", BCON_INT32(3), + "}", + "uplink", "{", + "value", BCON_INT32(1), + "unit", BCON_INT32(3), + "}", + "}", + "qos", "{", + "index", BCON_INT32(5), + "arp", "{", + "priority_level", BCON_INT32(1), + "pre_emption_vulnerability", BCON_INT32(1), + "pre_emption_capability", BCON_INT32(1), + "}", + "}", + "pcc_rule", "[", + "{", + "qos", "{", + "index", BCON_INT32(1), + "arp", "{", + "priority_level", BCON_INT32(3), + "pre_emption_vulnerability", BCON_INT32(2), + "pre_emption_capability", BCON_INT32(2), + "}", + "mbr", "{", + "downlink", "{", + "value", BCON_INT32(82), + "unit", BCON_INT32(1), + "}", + "uplink", "{", + "value", BCON_INT32(82), + "unit", BCON_INT32(1), + "}", + "}", + "gbr", "{", + "downlink", "{", + "value", BCON_INT32(82), + "unit", BCON_INT32(1), + "}", + "uplink", "{", + "value", BCON_INT32(82), + "unit", BCON_INT32(1), + "}", + "}", + "}", + "}", + "{", + "qos", "{", + "index", BCON_INT32(2), + "arp", "{", + "priority_level", BCON_INT32(4), + "pre_emption_vulnerability", BCON_INT32(2), + "pre_emption_capability", BCON_INT32(2), + "}", + "mbr", "{", + "downlink", "{", + "value", BCON_INT32(802), + "unit", BCON_INT32(1), + "}", + "uplink", "{", + "value", BCON_INT32(802), + "unit", BCON_INT32(1), + "}", + "}", + "gbr", "{", + "downlink", "{", + "value", BCON_INT32(802), + "unit", BCON_INT32(1), + "}", + "uplink", "{", + "value", BCON_INT32(802), + "unit", BCON_INT32(1), + "}", + "}", + "}", + "}", + "]", + "}", + "]", + "}", + "{", + "sst", BCON_INT32(1), + "sd", BCON_UTF8("009000"), + "default_indicator", BCON_BOOL(true), + "session", "[", + "{", + "name", BCON_UTF8("internet3"), + "type", BCON_INT32(3), + "ambr", "{", + "downlink", "{", + "value", BCON_INT32(1), + "unit", BCON_INT32(3), + "}", + "uplink", "{", + "value", BCON_INT32(1), + "unit", BCON_INT32(3), + "}", + "}", + "qos", "{", + "index", BCON_INT32(9), + "arp", "{", + "priority_level", BCON_INT32(8), + "pre_emption_vulnerability", BCON_INT32(1), + "pre_emption_capability", BCON_INT32(1), + "}", + "}", + "}", + "{", + "name", BCON_UTF8("ims3"), + "type", BCON_INT32(3), + "ambr", "{", + "downlink", "{", + "value", BCON_INT32(1), + "unit", BCON_INT32(3), + "}", + "uplink", "{", + "value", BCON_INT32(1), + "unit", BCON_INT32(3), + "}", + "}", + "qos", "{", + "index", BCON_INT32(5), + "arp", "{", + "priority_level", BCON_INT32(1), + "pre_emption_vulnerability", BCON_INT32(1), + "pre_emption_capability", BCON_INT32(1), + "}", + "}", + "pcc_rule", "[", + "{", + "qos", "{", + "index", BCON_INT32(1), + "arp", "{", + "priority_level", BCON_INT32(3), + "pre_emption_vulnerability", BCON_INT32(2), + "pre_emption_capability", BCON_INT32(2), + "}", + "mbr", "{", + "downlink", "{", + "value", BCON_INT32(82), + "unit", BCON_INT32(1), + "}", + "uplink", "{", + "value", BCON_INT32(82), + "unit", BCON_INT32(1), + "}", + "}", + "gbr", "{", + "downlink", "{", + "value", BCON_INT32(82), + "unit", BCON_INT32(1), + "}", + "uplink", "{", + "value", BCON_INT32(82), + "unit", BCON_INT32(1), + "}", + "}", + "}", + "}", + "{", + "qos", "{", + "index", BCON_INT32(2), + "arp", "{", + "priority_level", BCON_INT32(4), + "pre_emption_vulnerability", BCON_INT32(2), + "pre_emption_capability", BCON_INT32(2), + "}", + "mbr", "{", + "downlink", "{", + "value", BCON_INT32(802), + "unit", BCON_INT32(1), + "}", + "uplink", "{", + "value", BCON_INT32(802), + "unit", BCON_INT32(1), + "}", + "}", + "gbr", "{", + "downlink", "{", + "value", BCON_INT32(802), + "unit", BCON_INT32(1), + "}", + "uplink", "{", + "value", BCON_INT32(802), + "unit", BCON_INT32(1), + "}", + "}", + "}", + "}", + "]", + "}", + "]", + "}", + "]", + "security", "{", + "k", BCON_UTF8(test_ue->k_string), + "opc", BCON_UTF8(test_ue->opc_string), + "amf", BCON_UTF8("8000"), + "sqn", BCON_INT64(64), + "}", + "subscribed_rau_tau_timer", BCON_INT32(12), + "network_access_mode", BCON_INT32(0), + "subscriber_status", BCON_INT32(0), + "access_restriction_data", BCON_INT32(32) + ); + ogs_assert(doc); + + return doc; +} + bson_t *test_db_new_non3gpp(test_ue_t *test_ue) { bson_t *doc = NULL; diff --git a/tests/common/context.h b/tests/common/context.h index baa225343c..387620dded 100644 --- a/tests/common/context.h +++ b/tests/common/context.h @@ -523,7 +523,8 @@ bson_t *test_db_new_simple(test_ue_t *test_ue); bson_t *test_db_new_qos_flow(test_ue_t *test_ue); bson_t *test_db_new_session(test_ue_t *test_ue); bson_t *test_db_new_ims(test_ue_t *test_ue); -bson_t *test_db_new_slice(test_ue_t *test_ue); +bson_t *test_db_new_slice_with_same_dnn(test_ue_t *test_ue); +bson_t *test_db_new_slice_with_different_dnn(test_ue_t *test_ue); bson_t *test_db_new_non3gpp(test_ue_t *test_ue); #ifdef __cplusplus diff --git a/tests/slice/abts-main.c b/tests/slice/abts-main.c index 8c7b482f2d..d2ef2f36bd 100644 --- a/tests/slice/abts-main.c +++ b/tests/slice/abts-main.c @@ -19,12 +19,14 @@ #include "test-app.h" -abts_suite *test_nssai(abts_suite *suite); +abts_suite *test_same_dnn(abts_suite *suite); +abts_suite *test_different_dnn(abts_suite *suite); const struct testlist { abts_suite *(*func)(abts_suite *suite); } alltests[] = { - {test_nssai}, + {test_same_dnn}, + {test_different_dnn}, {NULL}, }; diff --git a/tests/slice/different-dnn-test.c b/tests/slice/different-dnn-test.c new file mode 100644 index 0000000000..f16b047865 --- /dev/null +++ b/tests/slice/different-dnn-test.c @@ -0,0 +1,249 @@ +/* + * Copyright (C) 2019,2020 by Sukchan Lee + * + * This file is part of Open5GS. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "test-common.h" + +static void test1_func(abts_case *tc, void *data) +{ + int rv; + ogs_socknode_t *ngap; + ogs_socknode_t *gtpu; + ogs_pkbuf_t *gmmbuf; + ogs_pkbuf_t *gsmbuf; + ogs_pkbuf_t *nasbuf; + ogs_pkbuf_t *sendbuf; + ogs_pkbuf_t *recvbuf; + ogs_ngap_message_t message; + int i; + + ogs_nas_5gs_mobile_identity_suci_t mobile_identity_suci; + test_ue_t *test_ue = NULL; + test_sess_t *sess = NULL; + test_bearer_t *qos_flow = NULL; + + bson_t *doc = NULL; + + /* Setup Test UE & Session Context */ + memset(&mobile_identity_suci, 0, sizeof(mobile_identity_suci)); + + mobile_identity_suci.h.supi_format = OGS_NAS_5GS_SUPI_FORMAT_IMSI; + mobile_identity_suci.h.type = OGS_NAS_5GS_MOBILE_IDENTITY_SUCI; + mobile_identity_suci.routing_indicator1 = 0; + mobile_identity_suci.routing_indicator2 = 0xf; + mobile_identity_suci.routing_indicator3 = 0xf; + mobile_identity_suci.routing_indicator4 = 0xf; + mobile_identity_suci.protection_scheme_id = OGS_NAS_5GS_NULL_SCHEME; + mobile_identity_suci.home_network_pki_value = 0; + mobile_identity_suci.scheme_output[0] = 0; + mobile_identity_suci.scheme_output[1] = 0; + mobile_identity_suci.scheme_output[2] = 0x47; + mobile_identity_suci.scheme_output[3] = 0x78; + + test_ue = test_ue_add_by_suci(&mobile_identity_suci, 12); + ogs_assert(test_ue); + + test_ue->nr_cgi.cell_id = 0x40001; + + test_ue->nas.registration.tsc = 0; + test_ue->nas.registration.ksi = 0; + test_ue->nas.registration.follow_on_request = 1; + test_ue->nas.registration.value = OGS_NAS_5GS_REGISTRATION_TYPE_INITIAL; + + test_ue->k_string = "465b5ce8b199b49faa5f0a2ee238a6bc"; + test_ue->opc_string = "e8ed289deba952e4283b54e88e6183ca"; + + /* gNB connects to AMF */ + ngap = testngap_client(AF_INET); + ABTS_PTR_NOTNULL(tc, ngap); + + /* gNB connects to UPF */ + gtpu = test_gtpu_server(1, AF_INET); + ABTS_PTR_NOTNULL(tc, gtpu); + + /* Send NG-Setup Reqeust */ + sendbuf = testngap_build_ng_setup_request(0x102, 32); + ABTS_PTR_NOTNULL(tc, sendbuf); + rv = testgnb_ngap_send(ngap, sendbuf); + ABTS_INT_EQUAL(tc, OGS_OK, rv); + + /* Receive NG-Setup Response */ + recvbuf = testgnb_ngap_read(ngap); + ABTS_PTR_NOTNULL(tc, recvbuf); + testngap_recv(test_ue, recvbuf); + + /********** Insert Subscriber in Database */ + doc = test_db_new_slice_with_different_dnn(test_ue); + ABTS_PTR_NOTNULL(tc, doc); + ABTS_INT_EQUAL(tc, OGS_OK, test_db_insert_ue(test_ue, doc)); + + /* Send Registration request */ + gmmbuf = testgmm_build_registration_request(test_ue, NULL, false, false); + ABTS_PTR_NOTNULL(tc, gmmbuf); + sendbuf = testngap_build_initial_ue_message(test_ue, gmmbuf, false, true); + ABTS_PTR_NOTNULL(tc, sendbuf); + rv = testgnb_ngap_send(ngap, sendbuf); + ABTS_INT_EQUAL(tc, OGS_OK, rv); + + /* Receive Authentication request */ + recvbuf = testgnb_ngap_read(ngap); + ABTS_PTR_NOTNULL(tc, recvbuf); + testngap_recv(test_ue, recvbuf); + + /* Send Authentication response */ + gmmbuf = testgmm_build_authentication_response(test_ue); + ABTS_PTR_NOTNULL(tc, gmmbuf); + sendbuf = testngap_build_uplink_nas_transport(test_ue, gmmbuf); + ABTS_PTR_NOTNULL(tc, sendbuf); + rv = testgnb_ngap_send(ngap, sendbuf); + ABTS_INT_EQUAL(tc, OGS_OK, rv); + + /* Receive Security mode command */ + recvbuf = testgnb_ngap_read(ngap); + ABTS_PTR_NOTNULL(tc, recvbuf); + testngap_recv(test_ue, recvbuf); + + /* Send Security mode complete */ + nasbuf = testgmm_build_registration_request(test_ue, NULL, false, false); + ABTS_PTR_NOTNULL(tc, nasbuf); + gmmbuf = testgmm_build_security_mode_complete(test_ue, nasbuf); + ABTS_PTR_NOTNULL(tc, gmmbuf); + sendbuf = testngap_build_uplink_nas_transport(test_ue, gmmbuf); + ABTS_PTR_NOTNULL(tc, sendbuf); + rv = testgnb_ngap_send(ngap, sendbuf); + ABTS_INT_EQUAL(tc, OGS_OK, rv); + + /* Receive Initial context setup request + + * Registration accept */ + recvbuf = testgnb_ngap_read(ngap); + ABTS_PTR_NOTNULL(tc, recvbuf); + testngap_recv(test_ue, recvbuf); + ABTS_INT_EQUAL(tc, + NGAP_ProcedureCode_id_InitialContextSetup, + test_ue->ngap_procedure_code); + + /* Send UE radio capability info indication */ + sendbuf = testngap_build_ue_radio_capability_info_indication(test_ue); + ABTS_PTR_NOTNULL(tc, sendbuf); + rv = testgnb_ngap_send(ngap, sendbuf); + ABTS_INT_EQUAL(tc, OGS_OK, rv); + + /* Send Initial context setup response */ + sendbuf = testngap_build_initial_context_setup_response(test_ue, false); + ABTS_PTR_NOTNULL(tc, sendbuf); + rv = testgnb_ngap_send(ngap, sendbuf); + ABTS_INT_EQUAL(tc, OGS_OK, rv); + + /* Send Registration complete */ + gmmbuf = testgmm_build_registration_complete(test_ue); + ABTS_PTR_NOTNULL(tc, gmmbuf); + sendbuf = testngap_build_uplink_nas_transport(test_ue, gmmbuf); + ABTS_PTR_NOTNULL(tc, sendbuf); + rv = testgnb_ngap_send(ngap, sendbuf); + ABTS_INT_EQUAL(tc, OGS_OK, rv); + + /* Receive Configuration update command */ + recvbuf = testgnb_ngap_read(ngap); + ABTS_PTR_NOTNULL(tc, recvbuf); + testngap_recv(test_ue, recvbuf); + + /* Send PDU session establishment request */ + sess = test_sess_add_by_dnn_and_psi(test_ue, "internet", 10); + ogs_assert(sess); + + sess->pti = 0; + sess->pdu_session_type = OGS_PDU_SESSION_TYPE_IPV4; + + sess->ul_nas_transport_param.request_type = + OGS_NAS_5GS_REQUEST_TYPE_INITIAL; + sess->ul_nas_transport_param.dnn = 1; + + sess->pdu_session_establishment_param.ssc_mode = 1; + sess->pdu_session_establishment_param.epco = 1; + + gsmbuf = testgsm_build_pdu_session_establishment_request(sess); + ABTS_PTR_NOTNULL(tc, gsmbuf); + gmmbuf = testgmm_build_ul_nas_transport(sess, + OGS_NAS_PAYLOAD_CONTAINER_N1_SM_INFORMATION, gsmbuf); + ABTS_PTR_NOTNULL(tc, gmmbuf); + sendbuf = testngap_build_uplink_nas_transport(test_ue, gmmbuf); + ABTS_PTR_NOTNULL(tc, sendbuf); + rv = testgnb_ngap_send(ngap, sendbuf); + ABTS_INT_EQUAL(tc, OGS_OK, rv); + + /* Receive PDUSessionResourceSetupRequest + + * DL NAS transport + + * PDU session establishment accept */ + recvbuf = testgnb_ngap_read(ngap); + ABTS_PTR_NOTNULL(tc, recvbuf); + testngap_recv(test_ue, recvbuf); + ABTS_INT_EQUAL(tc, + NGAP_ProcedureCode_id_PDUSessionResourceSetup, + test_ue->ngap_procedure_code); + + /* Send PDUSessionResourceSetupResponse */ + sendbuf = testngap_sess_build_pdu_session_resource_setup_response(sess); + ABTS_PTR_NOTNULL(tc, sendbuf); + rv = testgnb_ngap_send(ngap, sendbuf); + ABTS_INT_EQUAL(tc, OGS_OK, rv); + + /* Send UEContextReleaseRequest */ + sendbuf = testngap_build_ue_context_release_request(test_ue, + NGAP_Cause_PR_radioNetwork, NGAP_CauseRadioNetwork_user_inactivity, + true); + ABTS_PTR_NOTNULL(tc, sendbuf); + rv = testgnb_ngap_send(ngap, sendbuf); + ABTS_INT_EQUAL(tc, OGS_OK, rv); + + /* Receive UEContextReleaseCommand */ + recvbuf = testgnb_ngap_read(ngap); + ABTS_PTR_NOTNULL(tc, recvbuf); + testngap_recv(test_ue, recvbuf); + ABTS_INT_EQUAL(tc, + NGAP_ProcedureCode_id_UEContextRelease, + test_ue->ngap_procedure_code); + + /* Send UEContextReleaseComplete */ + sendbuf = testngap_build_ue_context_release_complete(test_ue); + ABTS_PTR_NOTNULL(tc, sendbuf); + rv = testgnb_ngap_send(ngap, sendbuf); + ABTS_INT_EQUAL(tc, OGS_OK, rv); + + ogs_msleep(300); + + /********** Remove Subscriber in Database */ + ABTS_INT_EQUAL(tc, OGS_OK, test_db_remove_ue(test_ue)); + + /* Clear Test UE Context */ + test_ue_remove(test_ue); + + /* gNB disonncect from UPF */ + testgnb_gtpu_close(gtpu); + + /* gNB disonncect from AMF */ + testgnb_ngap_close(ngap); +} + +abts_suite *test_different_dnn(abts_suite *suite) +{ + suite = ADD_SUITE(suite) + + abts_run_test(suite, test1_func, NULL); + + return suite; +} diff --git a/tests/slice/meson.build b/tests/slice/meson.build index 70595f5f9b..77e0f8a3d1 100644 --- a/tests/slice/meson.build +++ b/tests/slice/meson.build @@ -17,7 +17,8 @@ test5gc_slice_sources = files(''' abts-main.c - nssai-test.c + same-dnn-test.c + different-dnn-test.c '''.split()) test5gc_slice_exe = executable('slice', diff --git a/tests/slice/nssai-test.c b/tests/slice/same-dnn-test.c similarity index 99% rename from tests/slice/nssai-test.c rename to tests/slice/same-dnn-test.c index 9620cbd163..91a216ab77 100644 --- a/tests/slice/nssai-test.c +++ b/tests/slice/same-dnn-test.c @@ -88,7 +88,7 @@ static void test1_func(abts_case *tc, void *data) testngap_recv(test_ue, recvbuf); /********** Insert Subscriber in Database */ - doc = test_db_new_slice(test_ue); + doc = test_db_new_slice_with_same_dnn(test_ue); ABTS_PTR_NOTNULL(tc, doc); ABTS_INT_EQUAL(tc, OGS_OK, test_db_insert_ue(test_ue, doc)); @@ -391,7 +391,7 @@ static void test2_func(abts_case *tc, void *data) testngap_recv(test_ue, recvbuf); /********** Insert Subscriber in Database */ - doc = test_db_new_slice(test_ue); + doc = test_db_new_slice_with_same_dnn(test_ue); ABTS_PTR_NOTNULL(tc, doc); ABTS_INT_EQUAL(tc, OGS_OK, test_db_insert_ue(test_ue, doc)); @@ -588,7 +588,7 @@ static void test2_func(abts_case *tc, void *data) testgnb_ngap_close(ngap); } -abts_suite *test_nssai(abts_suite *suite) +abts_suite *test_same_dnn(abts_suite *suite) { suite = ADD_SUITE(suite)