2019-06-30 03:14:04 +00:00
|
|
|
/*
|
2023-03-19 09:25:59 +00:00
|
|
|
* Copyright (C) 2019-2023 by Sukchan Lee <acetcom@gmail.com>
|
2019-06-30 03:14:04 +00:00
|
|
|
*
|
|
|
|
|
* 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 <https://www.gnu.org/licenses/>.
|
|
|
|
|
*/
|
|
|
|
|
|
2019-05-31 07:33:09 +00:00
|
|
|
#include "ogs-sctp.h"
|
|
|
|
|
|
2019-06-11 13:10:47 +00:00
|
|
|
#include "mme-context.h"
|
|
|
|
|
#include "mme-event.h"
|
2019-07-20 02:20:09 +00:00
|
|
|
#include "mme-timer.h"
|
2019-09-13 12:07:47 +00:00
|
|
|
#include "nas-path.h"
|
2019-06-01 09:52:38 +00:00
|
|
|
#include "s1ap-path.h"
|
2019-06-11 13:10:47 +00:00
|
|
|
#include "s1ap-handler.h"
|
|
|
|
|
#include "mme-sm.h"
|
2022-01-31 13:58:52 +00:00
|
|
|
#include "mme-gtp-path.h"
|
2017-02-06 06:30:12 +00:00
|
|
|
|
2017-04-04 05:00:02 +00:00
|
|
|
#define MAX_CELL_PER_ENB 8
|
2017-03-05 04:03:11 +00:00
|
|
|
|
2017-04-06 11:10:00 +00:00
|
|
|
static mme_context_t self;
|
2019-09-13 12:07:47 +00:00
|
|
|
static ogs_diam_config_t g_diam_conf;
|
2017-02-06 06:30:12 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
int __mme_log_domain;
|
|
|
|
|
int __emm_log_domain;
|
|
|
|
|
int __esm_log_domain;
|
|
|
|
|
|
2023-07-06 16:03:42 +00:00
|
|
|
static OGS_POOL(mme_sgsn_route_pool, mme_sgsn_route_t);
|
|
|
|
|
static OGS_POOL(mme_sgsn_pool, mme_sgsn_t);
|
2019-04-27 14:54:30 +00:00
|
|
|
static OGS_POOL(mme_sgw_pool, mme_sgw_t);
|
|
|
|
|
static OGS_POOL(mme_pgw_pool, mme_pgw_t);
|
2019-06-02 12:55:24 +00:00
|
|
|
static OGS_POOL(mme_vlr_pool, mme_vlr_t);
|
2019-07-21 11:06:08 +00:00
|
|
|
static OGS_POOL(mme_csmap_pool, mme_csmap_t);
|
2018-09-23 04:16:40 +00:00
|
|
|
|
2020-04-27 02:18:47 +00:00
|
|
|
static OGS_POOL(mme_enb_pool, mme_enb_t);
|
2019-04-27 14:54:30 +00:00
|
|
|
static OGS_POOL(mme_ue_pool, mme_ue_t);
|
2023-04-09 01:34:19 +00:00
|
|
|
static OGS_POOL(mme_s11_teid_pool, ogs_pool_id_t);
|
2023-12-20 18:15:47 +00:00
|
|
|
static OGS_POOL(mme_gn_teid_pool, ogs_pool_id_t);
|
2019-04-27 14:54:30 +00:00
|
|
|
static OGS_POOL(enb_ue_pool, enb_ue_t);
|
2022-04-29 12:28:16 +00:00
|
|
|
static OGS_POOL(sgw_ue_pool, sgw_ue_t);
|
2019-04-27 14:54:30 +00:00
|
|
|
static OGS_POOL(mme_sess_pool, mme_sess_t);
|
2020-08-30 03:27:54 +00:00
|
|
|
static OGS_POOL(mme_bearer_pool, mme_bearer_t);
|
2017-02-13 04:19:53 +00:00
|
|
|
|
2023-04-09 01:34:19 +00:00
|
|
|
static OGS_POOL(m_tmsi_pool, mme_m_tmsi_t);
|
|
|
|
|
|
2017-04-06 11:10:00 +00:00
|
|
|
static int context_initialized = 0;
|
2017-02-06 06:30:12 +00:00
|
|
|
|
2020-09-05 03:36:51 +00:00
|
|
|
static int num_of_enb_ue = 0;
|
|
|
|
|
static int num_of_mme_sess = 0;
|
2019-11-05 06:23:33 +00:00
|
|
|
|
2020-09-05 03:36:51 +00:00
|
|
|
static void stats_add_enb_ue(void);
|
|
|
|
|
static void stats_remove_enb_ue(void);
|
|
|
|
|
static void stats_add_mme_session(void);
|
|
|
|
|
static void stats_remove_mme_session(void);
|
2019-11-05 06:23:33 +00:00
|
|
|
|
2022-04-29 12:28:16 +00:00
|
|
|
static bool compare_ue_info(mme_sgw_t *node, enb_ue_t *enb_ue);
|
|
|
|
|
static mme_sgw_t *selected_sgw_node(mme_sgw_t *current, enb_ue_t *enb_ue);
|
|
|
|
|
static mme_sgw_t *changed_sgw_node(mme_sgw_t *current, enb_ue_t *enb_ue);
|
|
|
|
|
|
2023-04-04 12:53:39 +00:00
|
|
|
void mme_context_init(void)
|
2017-02-06 06:30:12 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(context_initialized == 0);
|
2017-02-06 06:30:12 +00:00
|
|
|
|
2018-01-05 07:25:02 +00:00
|
|
|
/* Initial FreeDiameter Config */
|
2019-09-13 12:07:47 +00:00
|
|
|
memset(&g_diam_conf, 0, sizeof(ogs_diam_config_t));
|
2018-01-05 07:25:02 +00:00
|
|
|
|
2017-04-06 12:44:30 +00:00
|
|
|
/* Initialize MME context */
|
|
|
|
|
memset(&self, 0, sizeof(mme_context_t));
|
2019-09-13 12:07:47 +00:00
|
|
|
self.diam_config = &g_diam_conf;
|
2017-04-06 12:44:30 +00:00
|
|
|
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_log_install_domain(&__ogs_sctp_domain, "sctp", ogs_core()->log.level);
|
|
|
|
|
ogs_log_install_domain(&__ogs_s1ap_domain, "s1ap", ogs_core()->log.level);
|
|
|
|
|
ogs_log_install_domain(&__ogs_nas_domain, "nas", ogs_core()->log.level);
|
|
|
|
|
ogs_log_install_domain(&__ogs_diam_domain, "diam", ogs_core()->log.level);
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_log_install_domain(&__mme_log_domain, "mme", ogs_core()->log.level);
|
|
|
|
|
ogs_log_install_domain(&__emm_log_domain, "emm", ogs_core()->log.level);
|
|
|
|
|
ogs_log_install_domain(&__esm_log_domain, "esm", ogs_core()->log.level);
|
2017-12-01 12:47:15 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_list_init(&self.s1ap_list);
|
|
|
|
|
ogs_list_init(&self.s1ap_list6);
|
|
|
|
|
|
2023-07-06 16:03:42 +00:00
|
|
|
ogs_list_init(&self.sgsn_list);
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_list_init(&self.sgw_list);
|
|
|
|
|
ogs_list_init(&self.pgw_list);
|
2019-07-08 12:03:39 +00:00
|
|
|
ogs_list_init(&self.enb_list);
|
2019-06-02 12:55:24 +00:00
|
|
|
ogs_list_init(&self.vlr_list);
|
2019-07-21 11:06:08 +00:00
|
|
|
ogs_list_init(&self.csmap_list);
|
2017-04-12 01:05:23 +00:00
|
|
|
|
2023-07-06 16:03:42 +00:00
|
|
|
ogs_pool_init(&mme_sgsn_route_pool, ogs_app()->pool.nf);
|
|
|
|
|
ogs_pool_init(&mme_sgsn_pool, ogs_app()->pool.nf);
|
2020-08-26 03:05:01 +00:00
|
|
|
ogs_pool_init(&mme_sgw_pool, ogs_app()->pool.nf);
|
|
|
|
|
ogs_pool_init(&mme_pgw_pool, ogs_app()->pool.nf);
|
|
|
|
|
ogs_pool_init(&mme_vlr_pool, ogs_app()->pool.nf);
|
|
|
|
|
ogs_pool_init(&mme_csmap_pool, ogs_app()->pool.csmap);
|
2018-09-23 04:16:40 +00:00
|
|
|
|
2020-04-27 02:18:47 +00:00
|
|
|
/* Allocate TWICE the pool to check if maximum number of eNBs is reached */
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_pool_init(&mme_enb_pool, ogs_global_conf()->max.peer*2);
|
2020-04-27 02:18:47 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_pool_init(&mme_ue_pool, ogs_global_conf()->max.ue);
|
|
|
|
|
ogs_pool_init(&mme_s11_teid_pool, ogs_global_conf()->max.ue);
|
2023-04-09 01:34:19 +00:00
|
|
|
ogs_pool_random_id_generate(&mme_s11_teid_pool);
|
2023-12-20 18:15:47 +00:00
|
|
|
ogs_pool_init(&mme_gn_teid_pool, ogs_global_conf()->max.ue);
|
|
|
|
|
ogs_pool_random_id_generate(&mme_gn_teid_pool);
|
2023-04-09 01:34:19 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_pool_init(&enb_ue_pool, ogs_global_conf()->max.ue);
|
|
|
|
|
ogs_pool_init(&sgw_ue_pool, ogs_global_conf()->max.ue);
|
2020-08-26 03:05:01 +00:00
|
|
|
ogs_pool_init(&mme_sess_pool, ogs_app()->pool.sess);
|
2020-08-30 03:27:54 +00:00
|
|
|
ogs_pool_init(&mme_bearer_pool, ogs_app()->pool.bearer);
|
2024-01-21 02:55:46 +00:00
|
|
|
/* Increase size of TMSI pool (#1827) */
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_pool_init(&m_tmsi_pool, ogs_global_conf()->max.ue*2);
|
2023-04-09 01:34:19 +00:00
|
|
|
ogs_pool_random_id_generate(&m_tmsi_pool);
|
2024-01-21 02:55:46 +00:00
|
|
|
#if 0 /* For debugging : Verify whether there are duplicates of M_TMSI. */
|
|
|
|
|
ogs_pool_assert_if_has_duplicate(&m_tmsi_pool);
|
|
|
|
|
#endif
|
2017-02-13 04:19:53 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
self.enb_addr_hash = ogs_hash_make();
|
2021-06-06 13:35:46 +00:00
|
|
|
ogs_assert(self.enb_addr_hash);
|
2019-04-27 14:54:30 +00:00
|
|
|
self.enb_id_hash = ogs_hash_make();
|
2021-06-06 13:35:46 +00:00
|
|
|
ogs_assert(self.enb_id_hash);
|
2019-04-27 14:54:30 +00:00
|
|
|
self.imsi_ue_hash = ogs_hash_make();
|
2021-06-06 13:35:46 +00:00
|
|
|
ogs_assert(self.imsi_ue_hash);
|
2019-04-27 14:54:30 +00:00
|
|
|
self.guti_ue_hash = ogs_hash_make();
|
2021-06-06 13:35:46 +00:00
|
|
|
ogs_assert(self.guti_ue_hash);
|
2023-04-09 01:34:19 +00:00
|
|
|
self.mme_s11_teid_hash = ogs_hash_make();
|
|
|
|
|
ogs_assert(self.mme_s11_teid_hash);
|
2023-12-20 18:15:47 +00:00
|
|
|
self.mme_gn_teid_hash = ogs_hash_make();
|
|
|
|
|
ogs_assert(self.mme_gn_teid_hash);
|
2017-02-06 06:30:12 +00:00
|
|
|
|
2019-06-30 11:46:15 +00:00
|
|
|
ogs_list_init(&self.mme_ue_list);
|
|
|
|
|
|
2017-04-06 11:10:00 +00:00
|
|
|
context_initialized = 1;
|
2017-02-06 06:30:12 +00:00
|
|
|
}
|
2017-03-27 04:22:42 +00:00
|
|
|
|
2023-04-04 12:53:39 +00:00
|
|
|
void mme_context_final(void)
|
2017-07-30 13:29:27 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(context_initialized == 1);
|
2017-07-30 13:29:27 +00:00
|
|
|
|
2017-12-02 06:49:03 +00:00
|
|
|
mme_enb_remove_all();
|
2017-08-08 19:01:08 +00:00
|
|
|
mme_ue_remove_all();
|
2017-07-30 13:29:27 +00:00
|
|
|
|
2019-05-31 12:05:35 +00:00
|
|
|
mme_sgw_remove_all();
|
|
|
|
|
mme_pgw_remove_all();
|
2019-07-21 11:06:08 +00:00
|
|
|
mme_csmap_remove_all();
|
2019-06-02 12:55:24 +00:00
|
|
|
mme_vlr_remove_all();
|
2023-07-20 00:40:01 +00:00
|
|
|
mme_sgsn_remove_all();
|
2019-05-31 12:05:35 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(self.enb_addr_hash);
|
|
|
|
|
ogs_hash_destroy(self.enb_addr_hash);
|
|
|
|
|
ogs_assert(self.enb_id_hash);
|
|
|
|
|
ogs_hash_destroy(self.enb_id_hash);
|
|
|
|
|
|
|
|
|
|
ogs_assert(self.imsi_ue_hash);
|
|
|
|
|
ogs_hash_destroy(self.imsi_ue_hash);
|
|
|
|
|
ogs_assert(self.guti_ue_hash);
|
|
|
|
|
ogs_hash_destroy(self.guti_ue_hash);
|
2023-04-09 01:34:19 +00:00
|
|
|
ogs_assert(self.mme_s11_teid_hash);
|
|
|
|
|
ogs_hash_destroy(self.mme_s11_teid_hash);
|
2023-12-20 18:15:47 +00:00
|
|
|
ogs_assert(self.mme_gn_teid_hash);
|
|
|
|
|
ogs_hash_destroy(self.mme_gn_teid_hash);
|
2019-04-27 14:54:30 +00:00
|
|
|
|
2023-04-09 01:34:19 +00:00
|
|
|
ogs_pool_final(&m_tmsi_pool);
|
2020-08-30 03:27:54 +00:00
|
|
|
ogs_pool_final(&mme_bearer_pool);
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_pool_final(&mme_sess_pool);
|
|
|
|
|
ogs_pool_final(&mme_ue_pool);
|
2023-04-09 01:34:19 +00:00
|
|
|
ogs_pool_final(&mme_s11_teid_pool);
|
2023-12-20 18:15:47 +00:00
|
|
|
ogs_pool_final(&mme_gn_teid_pool);
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_pool_final(&enb_ue_pool);
|
2022-04-29 12:28:16 +00:00
|
|
|
ogs_pool_final(&sgw_ue_pool);
|
2019-04-27 14:54:30 +00:00
|
|
|
|
2020-04-27 02:18:47 +00:00
|
|
|
ogs_pool_final(&mme_enb_pool);
|
|
|
|
|
|
2023-07-06 16:03:42 +00:00
|
|
|
ogs_pool_final(&mme_sgsn_pool);
|
|
|
|
|
ogs_pool_final(&mme_sgsn_route_pool);
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_pool_final(&mme_sgw_pool);
|
|
|
|
|
ogs_pool_final(&mme_pgw_pool);
|
2019-07-21 11:06:08 +00:00
|
|
|
ogs_pool_final(&mme_csmap_pool);
|
2019-06-02 12:55:24 +00:00
|
|
|
ogs_pool_final(&mme_vlr_pool);
|
2018-09-23 04:16:40 +00:00
|
|
|
|
2017-07-30 13:29:27 +00:00
|
|
|
context_initialized = 0;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-27 08:41:14 +00:00
|
|
|
mme_context_t *mme_self(void)
|
2017-07-30 13:29:27 +00:00
|
|
|
{
|
|
|
|
|
return &self;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-27 08:41:14 +00:00
|
|
|
static int mme_context_prepare(void)
|
2017-07-14 11:04:11 +00:00
|
|
|
{
|
2017-02-06 10:12:10 +00:00
|
|
|
self.relative_capacity = 0xff;
|
2017-02-06 06:30:12 +00:00
|
|
|
|
2019-09-13 12:07:47 +00:00
|
|
|
self.s1ap_port = OGS_S1AP_SCTP_PORT;
|
|
|
|
|
self.sgsap_port = OGS_SGSAP_SCTP_PORT;
|
|
|
|
|
self.diam_config->cnf_port = DIAMETER_PORT;
|
|
|
|
|
self.diam_config->cnf_port_tls = DIAMETER_SECURE_PORT;
|
2017-07-14 11:04:11 +00:00
|
|
|
|
2023-08-13 02:16:06 +00:00
|
|
|
/* Set the default T3412 to 9 minutes for backward compatibility. */
|
|
|
|
|
self.time.t3412.value = 540;
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_OK;
|
2017-07-14 11:04:11 +00:00
|
|
|
}
|
2017-02-06 06:30:12 +00:00
|
|
|
|
2019-10-27 08:41:14 +00:00
|
|
|
static int mme_context_validation(void)
|
2017-07-14 11:04:11 +00:00
|
|
|
{
|
2022-11-29 14:22:16 +00:00
|
|
|
ogs_nas_gprs_timer_t gprs_timer;
|
|
|
|
|
|
2019-09-13 12:07:47 +00:00
|
|
|
if (self.diam_conf_path == NULL &&
|
|
|
|
|
(self.diam_config->cnf_diamid == NULL ||
|
|
|
|
|
self.diam_config->cnf_diamrlm == NULL ||
|
|
|
|
|
self.diam_config->cnf_addr == NULL)) {
|
2020-08-26 03:05:01 +00:00
|
|
|
ogs_error("No mme.freeDiameter in '%s'", ogs_app()->file);
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_ERROR;
|
2017-07-30 13:29:27 +00:00
|
|
|
}
|
2017-12-08 03:43:35 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
if (ogs_list_first(&self.s1ap_list) == NULL &&
|
2019-05-18 15:24:15 +00:00
|
|
|
ogs_list_first(&self.s1ap_list6) == NULL) {
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_error("No mme.s1ap.address in '%s'", ogs_app()->file);
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_RETRY;
|
2017-07-14 11:04:11 +00:00
|
|
|
}
|
2017-12-01 15:44:07 +00:00
|
|
|
|
2021-03-15 01:01:55 +00:00
|
|
|
if (ogs_list_first(&ogs_gtp_self()->gtpc_list) == NULL &&
|
|
|
|
|
ogs_list_first(&ogs_gtp_self()->gtpc_list6) == NULL) {
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_error("No mme.gtpc.address in '%s'", ogs_app()->file);
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_RETRY;
|
2017-07-14 11:04:11 +00:00
|
|
|
}
|
|
|
|
|
|
2019-05-18 15:24:15 +00:00
|
|
|
if (ogs_list_first(&self.sgw_list) == NULL) {
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_error("No sgw.gtpc.address in '%s'", ogs_app()->file);
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_ERROR;
|
2017-12-02 05:17:32 +00:00
|
|
|
}
|
2017-07-14 11:04:11 +00:00
|
|
|
|
2019-05-18 15:24:15 +00:00
|
|
|
if (ogs_list_first(&self.pgw_list) == NULL) {
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_error("No pgw.gtpc.address in '%s'", ogs_app()->file);
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_ERROR;
|
2017-12-03 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
|
2023-12-03 14:52:29 +00:00
|
|
|
if (self.num_of_served_gummei == 0) {
|
2020-08-26 03:05:01 +00:00
|
|
|
ogs_error("No mme.gummei in '%s'", ogs_app()->file);
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_ERROR;
|
2017-07-14 15:00:08 +00:00
|
|
|
}
|
|
|
|
|
|
2019-05-18 15:24:15 +00:00
|
|
|
if (self.served_gummei[0].num_of_plmn_id == 0) {
|
2020-08-26 03:05:01 +00:00
|
|
|
ogs_error("No mme.gummei.plmn_id in '%s'", ogs_app()->file);
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_ERROR;
|
2017-07-14 15:00:08 +00:00
|
|
|
}
|
|
|
|
|
|
2019-05-18 15:24:15 +00:00
|
|
|
if (self.served_gummei[0].num_of_mme_gid == 0) {
|
2020-08-26 03:05:01 +00:00
|
|
|
ogs_error("No mme.gummei.mme_gid in '%s'", ogs_app()->file);
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_ERROR;
|
2017-07-14 15:00:08 +00:00
|
|
|
}
|
|
|
|
|
|
2019-05-18 15:24:15 +00:00
|
|
|
if (self.served_gummei[0].num_of_mme_code == 0) {
|
2020-08-26 03:05:01 +00:00
|
|
|
ogs_error("No mme.gummei.mme_code in '%s'", ogs_app()->file);
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_ERROR;
|
2017-07-14 15:00:08 +00:00
|
|
|
}
|
|
|
|
|
|
2019-05-18 15:24:15 +00:00
|
|
|
if (self.num_of_served_tai == 0) {
|
2020-08-26 03:05:01 +00:00
|
|
|
ogs_error("No mme.tai in '%s'", ogs_app()->file);
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_ERROR;
|
2017-07-14 15:27:22 +00:00
|
|
|
}
|
|
|
|
|
|
2017-12-11 07:08:17 +00:00
|
|
|
if (self.served_tai[0].list0.tai[0].num == 0 &&
|
2023-10-28 12:30:32 +00:00
|
|
|
self.served_tai[0].list1.tai[0].num == 0 &&
|
2019-05-18 15:24:15 +00:00
|
|
|
self.served_tai[0].list2.num == 0) {
|
2020-08-26 03:05:01 +00:00
|
|
|
ogs_error("No mme.tai.plmn_id|tac in '%s'", ogs_app()->file);
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_ERROR;
|
2017-12-10 15:01:02 +00:00
|
|
|
}
|
|
|
|
|
|
2019-05-18 15:24:15 +00:00
|
|
|
if (self.num_of_integrity_order == 0) {
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_error("No mme.security.integrity_order in '%s'",
|
2020-08-26 03:05:01 +00:00
|
|
|
ogs_app()->file);
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_ERROR;
|
2017-07-14 11:46:15 +00:00
|
|
|
}
|
2019-05-18 15:24:15 +00:00
|
|
|
if (self.num_of_ciphering_order == 0) {
|
2023-08-13 02:16:06 +00:00
|
|
|
ogs_error("No mme.security.ciphering_order in '%s'",
|
2020-08-26 03:05:01 +00:00
|
|
|
ogs_app()->file);
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_ERROR;
|
2017-07-14 11:46:15 +00:00
|
|
|
}
|
2022-11-29 14:22:16 +00:00
|
|
|
if (ogs_nas_gprs_timer_from_sec(&gprs_timer, self.time.t3402.value) !=
|
|
|
|
|
OGS_OK) {
|
|
|
|
|
ogs_error("Not support GPRS Timer [%d]", (int)self.time.t3402.value);
|
|
|
|
|
return OGS_ERROR;
|
|
|
|
|
}
|
2023-08-13 02:16:06 +00:00
|
|
|
if (!self.time.t3412.value) {
|
|
|
|
|
ogs_error("No mme.time.t3412.value in '%s'",
|
|
|
|
|
ogs_app()->file);
|
|
|
|
|
return OGS_ERROR;
|
|
|
|
|
}
|
2022-11-29 14:22:16 +00:00
|
|
|
if (ogs_nas_gprs_timer_from_sec(&gprs_timer, self.time.t3412.value) !=
|
|
|
|
|
OGS_OK) {
|
|
|
|
|
ogs_error("Not support GPRS Timer [%d]", (int)self.time.t3412.value);
|
|
|
|
|
return OGS_ERROR;
|
|
|
|
|
}
|
|
|
|
|
if (ogs_nas_gprs_timer_from_sec(&gprs_timer, self.time.t3423.value) !=
|
|
|
|
|
OGS_OK) {
|
|
|
|
|
ogs_error("Not support GPRS Timer [%d]", (int)self.time.t3423.value);
|
|
|
|
|
return OGS_ERROR;
|
|
|
|
|
}
|
2017-02-06 06:30:12 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_OK;
|
2017-07-14 11:04:11 +00:00
|
|
|
}
|
2017-03-07 00:30:12 +00:00
|
|
|
|
2023-07-06 16:03:42 +00:00
|
|
|
static int parse_plmn_id(ogs_yaml_iter_t *parent_iter, ogs_plmn_id_t *plmn_id)
|
|
|
|
|
{
|
|
|
|
|
const char *mcc = NULL;
|
|
|
|
|
const char *mnc = NULL;
|
|
|
|
|
ogs_yaml_iter_t plmn_id_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(parent_iter,
|
|
|
|
|
&plmn_id_iter);
|
|
|
|
|
|
|
|
|
|
while (ogs_yaml_iter_next(&plmn_id_iter)) {
|
|
|
|
|
const char *plmn_id_key = ogs_yaml_iter_key(&plmn_id_iter);
|
|
|
|
|
ogs_assert(plmn_id_key);
|
|
|
|
|
|
|
|
|
|
if (!strcmp(plmn_id_key, "mcc")) {
|
|
|
|
|
mcc = ogs_yaml_iter_value(&plmn_id_iter);
|
|
|
|
|
} else if (!strcmp(plmn_id_key, "mnc")) {
|
|
|
|
|
mnc = ogs_yaml_iter_value(&plmn_id_iter);
|
|
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown key `%s`", plmn_id_key);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!mcc || ! mnc)
|
|
|
|
|
return OGS_ERROR;
|
|
|
|
|
|
|
|
|
|
ogs_plmn_id_build(plmn_id, atoi(mcc), atoi(mnc), strlen(mnc));
|
|
|
|
|
return OGS_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int parse_lai(ogs_yaml_iter_t *parent_iter, ogs_nas_lai_t *lai)
|
|
|
|
|
{
|
|
|
|
|
bool plmn_id_parsed = false;
|
|
|
|
|
const char *lac = NULL;
|
|
|
|
|
ogs_plmn_id_t plmn_id;
|
|
|
|
|
ogs_yaml_iter_t lai_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(parent_iter, &lai_iter);
|
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
|
|
while (ogs_yaml_iter_next(&lai_iter)) {
|
|
|
|
|
const char *lai_key = ogs_yaml_iter_key(&lai_iter);
|
|
|
|
|
ogs_assert(lai_key);
|
|
|
|
|
|
|
|
|
|
if (!strcmp(lai_key, "plmn_id")) {
|
|
|
|
|
rc = parse_plmn_id(&lai_iter, &plmn_id);
|
|
|
|
|
ogs_assert(rc == OGS_OK);
|
|
|
|
|
plmn_id_parsed = true;
|
|
|
|
|
} else if (!strcmp(lai_key, "lac")) {
|
|
|
|
|
lac = ogs_yaml_iter_value(
|
|
|
|
|
&lai_iter);
|
|
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown key `%s`",
|
|
|
|
|
lai_key);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!plmn_id_parsed || !lac)
|
|
|
|
|
return OGS_ERROR;
|
|
|
|
|
|
|
|
|
|
ogs_nas_from_plmn_id( &lai->nas_plmn_id, &plmn_id);
|
|
|
|
|
lai->lac = atoi(lac);
|
|
|
|
|
return OGS_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int parse_rai(ogs_yaml_iter_t *parent_iter, ogs_nas_rai_t *rai)
|
|
|
|
|
{
|
|
|
|
|
bool lai_parsed = false, rac_parsed = false;
|
|
|
|
|
int rc;
|
|
|
|
|
ogs_yaml_iter_t rai_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(parent_iter, &rai_iter);
|
|
|
|
|
|
|
|
|
|
while (ogs_yaml_iter_next(&rai_iter)) {
|
|
|
|
|
const char *rai_key = ogs_yaml_iter_key(&rai_iter);
|
|
|
|
|
ogs_assert(rai_key);
|
|
|
|
|
|
|
|
|
|
if (!strcmp(rai_key, "lai")) {
|
|
|
|
|
rc = parse_lai(&rai_iter, &rai->lai);
|
|
|
|
|
ogs_assert(rc == OGS_OK);
|
|
|
|
|
lai_parsed = true;
|
|
|
|
|
} else if (!strcmp(rai_key, "rac")) {
|
|
|
|
|
const char *v = ogs_yaml_iter_value(&rai_iter);
|
|
|
|
|
rai->rac = atoi(v);
|
|
|
|
|
rac_parsed = true;
|
|
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown key `%s`", rai_key);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!lai_parsed || !rac_parsed)
|
|
|
|
|
return OGS_ERROR;
|
|
|
|
|
return OGS_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-04 12:53:39 +00:00
|
|
|
int mme_context_parse_config(void)
|
2017-07-14 10:00:26 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
int rv;
|
2017-11-29 00:41:29 +00:00
|
|
|
yaml_document_t *document = NULL;
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_t root_iter;
|
2017-07-14 10:00:26 +00:00
|
|
|
|
2020-08-26 03:05:01 +00:00
|
|
|
document = ogs_app()->document;
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(document);
|
2017-07-14 10:00:26 +00:00
|
|
|
|
2017-07-14 11:04:11 +00:00
|
|
|
rv = mme_context_prepare();
|
2019-04-27 14:54:30 +00:00
|
|
|
if (rv != OGS_OK) return rv;
|
2017-07-14 11:04:11 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_init(&root_iter, document);
|
2019-05-29 12:27:22 +00:00
|
|
|
while (ogs_yaml_iter_next(&root_iter)) {
|
2019-04-27 14:54:30 +00:00
|
|
|
const char *root_key = ogs_yaml_iter_key(&root_iter);
|
|
|
|
|
ogs_assert(root_key);
|
2019-05-18 15:24:15 +00:00
|
|
|
if (!strcmp(root_key, "mme")) {
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_t mme_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&root_iter, &mme_iter);
|
2019-05-29 12:27:22 +00:00
|
|
|
while (ogs_yaml_iter_next(&mme_iter)) {
|
2019-04-27 14:54:30 +00:00
|
|
|
const char *mme_key = ogs_yaml_iter_key(&mme_iter);
|
|
|
|
|
ogs_assert(mme_key);
|
2019-05-18 15:24:15 +00:00
|
|
|
if (!strcmp(mme_key, "freeDiameter")) {
|
2022-03-01 08:13:40 +00:00
|
|
|
yaml_node_t *node =
|
2018-01-05 14:03:41 +00:00
|
|
|
yaml_document_get_node(document, mme_iter.pair->value);
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(node);
|
2019-05-18 15:24:15 +00:00
|
|
|
if (node->type == YAML_SCALAR_NODE) {
|
2019-09-13 12:07:47 +00:00
|
|
|
self.diam_conf_path = ogs_yaml_iter_value(&mme_iter);
|
2019-06-02 02:09:01 +00:00
|
|
|
} else if (node->type == YAML_MAPPING_NODE) {
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_t fd_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&mme_iter, &fd_iter);
|
2018-01-05 14:03:41 +00:00
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
while (ogs_yaml_iter_next(&fd_iter)) {
|
2019-04-27 14:54:30 +00:00
|
|
|
const char *fd_key = ogs_yaml_iter_key(&fd_iter);
|
|
|
|
|
ogs_assert(fd_key);
|
2019-05-18 15:24:15 +00:00
|
|
|
if (!strcmp(fd_key, "identity")) {
|
2022-03-01 08:13:40 +00:00
|
|
|
self.diam_config->cnf_diamid =
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_value(&fd_iter);
|
2019-06-02 02:09:01 +00:00
|
|
|
} else if (!strcmp(fd_key, "realm")) {
|
2022-03-01 08:13:40 +00:00
|
|
|
self.diam_config->cnf_diamrlm =
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_value(&fd_iter);
|
2019-06-02 02:09:01 +00:00
|
|
|
} else if (!strcmp(fd_key, "port")) {
|
2019-04-27 14:54:30 +00:00
|
|
|
const char *v = ogs_yaml_iter_value(&fd_iter);
|
2019-09-13 12:07:47 +00:00
|
|
|
if (v) self.diam_config->cnf_port = atoi(v);
|
2019-06-02 02:09:01 +00:00
|
|
|
} else if (!strcmp(fd_key, "sec_port")) {
|
2019-04-27 14:54:30 +00:00
|
|
|
const char *v = ogs_yaml_iter_value(&fd_iter);
|
2019-09-13 12:07:47 +00:00
|
|
|
if (v) self.diam_config->cnf_port_tls = atoi(v);
|
2019-06-02 02:09:01 +00:00
|
|
|
} else if (!strcmp(fd_key, "listen_on")) {
|
2022-03-01 08:13:40 +00:00
|
|
|
self.diam_config->cnf_addr =
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_value(&fd_iter);
|
2021-06-21 13:36:38 +00:00
|
|
|
} else if (!strcmp(fd_key, "no_fwd")) {
|
|
|
|
|
self.diam_config->cnf_flags.no_fwd =
|
|
|
|
|
ogs_yaml_iter_bool(&fd_iter);
|
2019-06-02 12:55:24 +00:00
|
|
|
} else if (!strcmp(fd_key, "load_extension")) {
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_t ext_array, ext_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&fd_iter, &ext_array);
|
2019-05-18 15:24:15 +00:00
|
|
|
do {
|
2018-01-05 14:03:41 +00:00
|
|
|
const char *module = NULL;
|
|
|
|
|
const char *conf = NULL;
|
2018-01-05 07:25:02 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
if (ogs_yaml_iter_type(&ext_array) ==
|
2019-05-18 15:24:15 +00:00
|
|
|
YAML_MAPPING_NODE) {
|
2018-01-05 14:03:41 +00:00
|
|
|
memcpy(&ext_iter, &ext_array,
|
2019-04-27 14:54:30 +00:00
|
|
|
sizeof(ogs_yaml_iter_t));
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (ogs_yaml_iter_type(&ext_array) ==
|
2019-05-18 15:24:15 +00:00
|
|
|
YAML_SEQUENCE_NODE) {
|
2019-04-27 14:54:30 +00:00
|
|
|
if (!ogs_yaml_iter_next(&ext_array))
|
2018-01-05 14:03:41 +00:00
|
|
|
break;
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_recurse(
|
2018-01-05 14:03:41 +00:00
|
|
|
&ext_array, &ext_iter);
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (ogs_yaml_iter_type(&ext_array) ==
|
2019-05-18 15:24:15 +00:00
|
|
|
YAML_SCALAR_NODE) {
|
2018-01-05 14:03:41 +00:00
|
|
|
break;
|
2019-06-02 02:09:01 +00:00
|
|
|
} else
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert_if_reached();
|
2018-01-05 07:25:02 +00:00
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
while (ogs_yaml_iter_next(&ext_iter)) {
|
2018-01-05 14:03:41 +00:00
|
|
|
const char *ext_key =
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_key(&ext_iter);
|
|
|
|
|
ogs_assert(ext_key);
|
2019-05-18 15:24:15 +00:00
|
|
|
if (!strcmp(ext_key, "module")) {
|
|
|
|
|
module =
|
|
|
|
|
ogs_yaml_iter_value(&ext_iter);
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (!strcmp(ext_key, "conf")) {
|
2019-05-18 15:24:15 +00:00
|
|
|
conf =
|
|
|
|
|
ogs_yaml_iter_value(&ext_iter);
|
2019-05-29 12:27:22 +00:00
|
|
|
} else
|
2019-05-18 15:24:15 +00:00
|
|
|
ogs_warn("unknown key `%s`",
|
|
|
|
|
ext_key);
|
2018-01-05 14:03:41 +00:00
|
|
|
}
|
2018-01-05 07:25:02 +00:00
|
|
|
|
2019-05-18 15:24:15 +00:00
|
|
|
if (module) {
|
2019-09-13 12:07:47 +00:00
|
|
|
self.diam_config->
|
|
|
|
|
ext[self.diam_config->num_of_ext].
|
2018-01-05 14:03:41 +00:00
|
|
|
module = module;
|
2019-09-13 12:07:47 +00:00
|
|
|
self.diam_config->
|
|
|
|
|
ext[self.diam_config->num_of_ext].
|
2018-01-05 14:03:41 +00:00
|
|
|
conf = conf;
|
2019-09-13 12:07:47 +00:00
|
|
|
self.diam_config->num_of_ext++;
|
2018-01-05 14:03:41 +00:00
|
|
|
}
|
2019-05-29 12:27:22 +00:00
|
|
|
} while (ogs_yaml_iter_type(&ext_array) ==
|
2018-01-05 14:03:41 +00:00
|
|
|
YAML_SEQUENCE_NODE);
|
2019-06-02 02:09:01 +00:00
|
|
|
} else if (!strcmp(fd_key, "connect")) {
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_t conn_array, conn_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&fd_iter, &conn_array);
|
2019-05-18 15:24:15 +00:00
|
|
|
do {
|
2018-01-05 14:03:41 +00:00
|
|
|
const char *identity = NULL;
|
|
|
|
|
const char *addr = NULL;
|
2019-04-27 14:54:30 +00:00
|
|
|
uint16_t port = 0;
|
2018-01-05 07:25:02 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
if (ogs_yaml_iter_type(&conn_array) ==
|
2019-05-18 15:24:15 +00:00
|
|
|
YAML_MAPPING_NODE) {
|
2018-01-05 14:03:41 +00:00
|
|
|
memcpy(&conn_iter, &conn_array,
|
2019-04-27 14:54:30 +00:00
|
|
|
sizeof(ogs_yaml_iter_t));
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (ogs_yaml_iter_type(
|
|
|
|
|
&conn_array) == YAML_SEQUENCE_NODE) {
|
2019-04-27 14:54:30 +00:00
|
|
|
if (!ogs_yaml_iter_next(&conn_array))
|
2018-01-05 14:03:41 +00:00
|
|
|
break;
|
2020-04-27 02:18:47 +00:00
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&conn_array, &conn_iter);
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (ogs_yaml_iter_type(
|
|
|
|
|
&conn_array) == YAML_SCALAR_NODE) {
|
2018-01-05 14:03:41 +00:00
|
|
|
break;
|
2019-05-29 12:27:22 +00:00
|
|
|
} else
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert_if_reached();
|
2018-01-05 07:25:02 +00:00
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
while (ogs_yaml_iter_next(&conn_iter)) {
|
2018-01-05 14:03:41 +00:00
|
|
|
const char *conn_key =
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_key(&conn_iter);
|
|
|
|
|
ogs_assert(conn_key);
|
2019-05-18 15:24:15 +00:00
|
|
|
if (!strcmp(conn_key, "identity")) {
|
|
|
|
|
identity =
|
|
|
|
|
ogs_yaml_iter_value(&conn_iter);
|
2023-11-19 10:34:51 +00:00
|
|
|
} else if (!strcmp(conn_key,
|
|
|
|
|
"address")) {
|
2019-05-18 15:24:15 +00:00
|
|
|
addr =
|
|
|
|
|
ogs_yaml_iter_value(&conn_iter);
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (!strcmp(conn_key, "port")) {
|
2018-01-05 14:03:41 +00:00
|
|
|
const char *v =
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_value(&conn_iter);
|
2018-01-05 14:03:41 +00:00
|
|
|
if (v) port = atoi(v);
|
2019-05-29 12:27:22 +00:00
|
|
|
} else
|
2019-05-18 15:24:15 +00:00
|
|
|
ogs_warn("unknown key `%s`",
|
|
|
|
|
conn_key);
|
2018-01-05 14:03:41 +00:00
|
|
|
}
|
|
|
|
|
|
2019-05-18 15:24:15 +00:00
|
|
|
if (identity && addr) {
|
2019-09-13 12:07:47 +00:00
|
|
|
self.diam_config->
|
|
|
|
|
conn[self.diam_config->num_of_conn].
|
2018-01-05 14:03:41 +00:00
|
|
|
identity = identity;
|
2019-09-13 12:07:47 +00:00
|
|
|
self.diam_config->
|
|
|
|
|
conn[self.diam_config->num_of_conn].
|
2018-01-05 14:03:41 +00:00
|
|
|
addr = addr;
|
2019-09-13 12:07:47 +00:00
|
|
|
self.diam_config->
|
|
|
|
|
conn[self.diam_config->num_of_conn].
|
2018-01-05 14:03:41 +00:00
|
|
|
port = port;
|
2019-09-13 12:07:47 +00:00
|
|
|
self.diam_config->num_of_conn++;
|
2018-01-05 14:03:41 +00:00
|
|
|
}
|
2019-05-29 12:27:22 +00:00
|
|
|
} while (ogs_yaml_iter_type(&conn_array) ==
|
2018-01-05 14:03:41 +00:00
|
|
|
YAML_SEQUENCE_NODE);
|
2019-06-02 02:09:01 +00:00
|
|
|
} else
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_warn("unknown key `%s`", fd_key);
|
2018-01-05 07:25:02 +00:00
|
|
|
}
|
|
|
|
|
}
|
2019-06-02 02:09:01 +00:00
|
|
|
} else if (!strcmp(mme_key, "relative_capacity")) {
|
2019-04-27 14:54:30 +00:00
|
|
|
const char *v = ogs_yaml_iter_value(&mme_iter);
|
2017-11-29 00:41:29 +00:00
|
|
|
if (v) self.relative_capacity = atoi(v);
|
2019-06-02 02:09:01 +00:00
|
|
|
} else if (!strcmp(mme_key, "s1ap")) {
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_yaml_iter_t s1ap_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&mme_iter, &s1ap_iter);
|
|
|
|
|
while (ogs_yaml_iter_next(&s1ap_iter)) {
|
|
|
|
|
const char *s1ap_key = ogs_yaml_iter_key(&s1ap_iter);
|
|
|
|
|
ogs_assert(s1ap_key);
|
|
|
|
|
if (!strcmp(s1ap_key, "server")) {
|
|
|
|
|
ogs_yaml_iter_t server_iter, server_array;
|
|
|
|
|
ogs_yaml_iter_recurse(&s1ap_iter, &server_array);
|
|
|
|
|
do {
|
|
|
|
|
int family = AF_UNSPEC;
|
|
|
|
|
int i, num = 0;
|
|
|
|
|
const char *hostname[OGS_MAX_NUM_OF_HOSTNAME];
|
|
|
|
|
uint16_t port = self.s1ap_port;
|
|
|
|
|
const char *dev = NULL;
|
|
|
|
|
ogs_sockaddr_t *addr = NULL;
|
2017-11-24 15:52:07 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_sockopt_t option;
|
|
|
|
|
bool is_option = false;
|
2022-03-15 13:03:50 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
if (ogs_yaml_iter_type(&server_array) ==
|
|
|
|
|
YAML_MAPPING_NODE) {
|
|
|
|
|
memcpy(&server_iter, &server_array,
|
|
|
|
|
sizeof(ogs_yaml_iter_t));
|
|
|
|
|
} else if (ogs_yaml_iter_type(&server_array) ==
|
|
|
|
|
YAML_SEQUENCE_NODE) {
|
|
|
|
|
if (!ogs_yaml_iter_next(&server_array))
|
|
|
|
|
break;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&server_array, &server_iter);
|
|
|
|
|
} else if (ogs_yaml_iter_type(&server_array) ==
|
|
|
|
|
YAML_SCALAR_NODE) {
|
|
|
|
|
break;
|
|
|
|
|
} else
|
|
|
|
|
ogs_assert_if_reached();
|
|
|
|
|
|
|
|
|
|
while (ogs_yaml_iter_next(&server_iter)) {
|
|
|
|
|
const char *server_key =
|
|
|
|
|
ogs_yaml_iter_key(&server_iter);
|
|
|
|
|
ogs_assert(server_key);
|
|
|
|
|
if (!strcmp(server_key, "family")) {
|
|
|
|
|
const char *v =
|
|
|
|
|
ogs_yaml_iter_value(&server_iter);
|
|
|
|
|
if (v) family = atoi(v);
|
|
|
|
|
if (family != AF_UNSPEC &&
|
|
|
|
|
family != AF_INET &&
|
|
|
|
|
family != AF_INET6) {
|
|
|
|
|
ogs_warn("Ignore family(%d) : "
|
|
|
|
|
"AF_UNSPEC(%d), "
|
|
|
|
|
"AF_INET(%d), AF_INET6(%d) ",
|
|
|
|
|
family,
|
|
|
|
|
AF_UNSPEC, AF_INET, AF_INET6);
|
|
|
|
|
family = AF_UNSPEC;
|
|
|
|
|
}
|
|
|
|
|
} else if (!strcmp(server_key, "address")) {
|
|
|
|
|
ogs_yaml_iter_t hostname_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&server_iter, &hostname_iter);
|
|
|
|
|
ogs_assert(ogs_yaml_iter_type(
|
|
|
|
|
&hostname_iter) !=
|
|
|
|
|
YAML_MAPPING_NODE);
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
if (ogs_yaml_iter_type(
|
|
|
|
|
&hostname_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE) {
|
|
|
|
|
if (!ogs_yaml_iter_next(
|
|
|
|
|
&hostname_iter))
|
|
|
|
|
break;
|
|
|
|
|
}
|
2017-11-24 15:52:07 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_assert(num <
|
|
|
|
|
OGS_MAX_NUM_OF_HOSTNAME);
|
|
|
|
|
hostname[num++] =
|
|
|
|
|
ogs_yaml_iter_value(
|
|
|
|
|
&hostname_iter);
|
|
|
|
|
} while (ogs_yaml_iter_type(
|
|
|
|
|
&hostname_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
|
|
|
|
} else if (!strcmp(server_key, "port")) {
|
|
|
|
|
const char *v =
|
|
|
|
|
ogs_yaml_iter_value(&server_iter);
|
|
|
|
|
if (v) port = atoi(v);
|
|
|
|
|
} else if (!strcmp(server_key, "dev")) {
|
|
|
|
|
dev = ogs_yaml_iter_value(&server_iter);
|
|
|
|
|
} else if (!strcmp(server_key, "option")) {
|
|
|
|
|
rv = ogs_app_parse_sockopt_config(
|
|
|
|
|
&server_iter, &option);
|
|
|
|
|
if (rv != OGS_OK) {
|
|
|
|
|
ogs_error("ogs_app_parse_sockopt_"
|
|
|
|
|
"config() failed");
|
|
|
|
|
return rv;
|
|
|
|
|
}
|
|
|
|
|
is_option = true;
|
|
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown key `%s`",
|
|
|
|
|
server_key);
|
2017-11-24 15:52:07 +00:00
|
|
|
}
|
2017-12-08 03:43:35 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
addr = NULL;
|
|
|
|
|
for (i = 0; i < num; i++) {
|
|
|
|
|
rv = ogs_addaddrinfo(&addr,
|
|
|
|
|
family, hostname[i], port, 0);
|
|
|
|
|
ogs_assert(rv == OGS_OK);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (addr) {
|
|
|
|
|
if (ogs_global_conf()->parameter.
|
|
|
|
|
no_ipv4 == 0)
|
|
|
|
|
ogs_socknode_add(
|
|
|
|
|
&self.s1ap_list, AF_INET, addr,
|
|
|
|
|
is_option ? &option : NULL);
|
|
|
|
|
if (ogs_global_conf()->parameter.
|
|
|
|
|
no_ipv6 == 0)
|
|
|
|
|
ogs_socknode_add(
|
|
|
|
|
&self.s1ap_list6, AF_INET6, addr,
|
|
|
|
|
is_option ? &option : NULL);
|
|
|
|
|
ogs_freeaddrinfo(addr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (dev) {
|
|
|
|
|
rv = ogs_socknode_probe(
|
|
|
|
|
ogs_global_conf()->parameter.
|
|
|
|
|
no_ipv4 ?
|
|
|
|
|
NULL : &self.s1ap_list,
|
|
|
|
|
ogs_global_conf()->parameter.
|
|
|
|
|
no_ipv6 ?
|
|
|
|
|
NULL : &self.s1ap_list6,
|
|
|
|
|
dev, port,
|
|
|
|
|
is_option ? &option : NULL);
|
|
|
|
|
ogs_assert(rv == OGS_OK);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} while (ogs_yaml_iter_type(&server_array) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
|
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown key `%s`", s1ap_key);
|
|
|
|
|
}
|
|
|
|
|
} else if (!strcmp(mme_key, "gtpc")) {
|
|
|
|
|
ogs_yaml_iter_t gtpc_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&mme_iter, >pc_iter);
|
|
|
|
|
while (ogs_yaml_iter_next(>pc_iter)) {
|
|
|
|
|
const char *gtpc_key = ogs_yaml_iter_key(>pc_iter);
|
|
|
|
|
ogs_assert(gtpc_key);
|
|
|
|
|
if (!strcmp(gtpc_key, "server")) {
|
|
|
|
|
/* handle config in gtp library */
|
|
|
|
|
} else if (!strcmp(gtpc_key, "client")) {
|
|
|
|
|
ogs_yaml_iter_t client_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(>pc_iter, &client_iter);
|
|
|
|
|
while (ogs_yaml_iter_next(&client_iter)) {
|
|
|
|
|
const char *client_key =
|
|
|
|
|
ogs_yaml_iter_key(&client_iter);
|
|
|
|
|
ogs_assert(client_key);
|
|
|
|
|
if (!strcmp(client_key, "sgwc")) {
|
|
|
|
|
ogs_yaml_iter_t sgwc_array, sgwc_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&client_iter, &sgwc_array);
|
|
|
|
|
do {
|
|
|
|
|
mme_sgw_t *sgw = NULL;
|
|
|
|
|
ogs_sockaddr_t *addr = NULL;
|
|
|
|
|
int family = AF_UNSPEC;
|
|
|
|
|
int i, num = 0;
|
|
|
|
|
const char *hostname[
|
|
|
|
|
OGS_MAX_NUM_OF_HOSTNAME];
|
|
|
|
|
uint16_t port =
|
|
|
|
|
ogs_gtp_self()->gtpc_port;
|
|
|
|
|
uint16_t tac[OGS_MAX_NUM_OF_TAI] = {0,};
|
|
|
|
|
int num_of_tac = 0;
|
|
|
|
|
uint32_t e_cell_id[
|
|
|
|
|
OGS_MAX_NUM_OF_CELL_ID] = {0,};
|
|
|
|
|
int num_of_e_cell_id = 0;
|
|
|
|
|
|
|
|
|
|
if (ogs_yaml_iter_type(&sgwc_array) ==
|
|
|
|
|
YAML_MAPPING_NODE) {
|
|
|
|
|
memcpy(&sgwc_iter, &sgwc_array,
|
|
|
|
|
sizeof(ogs_yaml_iter_t));
|
|
|
|
|
} else if (ogs_yaml_iter_type(
|
|
|
|
|
&sgwc_array) ==
|
|
|
|
|
YAML_SEQUENCE_NODE) {
|
|
|
|
|
if (!ogs_yaml_iter_next(
|
|
|
|
|
&sgwc_array))
|
|
|
|
|
break;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&sgwc_array, &sgwc_iter);
|
|
|
|
|
} else if (ogs_yaml_iter_type(
|
|
|
|
|
&sgwc_array) ==
|
|
|
|
|
YAML_SCALAR_NODE) {
|
|
|
|
|
break;
|
|
|
|
|
} else
|
|
|
|
|
ogs_assert_if_reached();
|
|
|
|
|
|
|
|
|
|
while (ogs_yaml_iter_next(&sgwc_iter)) {
|
|
|
|
|
const char *sgwc_key =
|
|
|
|
|
ogs_yaml_iter_key(&sgwc_iter);
|
|
|
|
|
ogs_assert(sgwc_key);
|
|
|
|
|
if (!strcmp(sgwc_key, "family")) {
|
|
|
|
|
const char *v =
|
|
|
|
|
ogs_yaml_iter_value(
|
|
|
|
|
&sgwc_iter);
|
|
|
|
|
if (v) family = atoi(v);
|
|
|
|
|
if (family != AF_UNSPEC &&
|
|
|
|
|
family != AF_INET &&
|
|
|
|
|
family != AF_INET6) {
|
|
|
|
|
ogs_warn(
|
|
|
|
|
"Ignore family(%d) : "
|
|
|
|
|
"AF_UNSPEC(%d), "
|
|
|
|
|
"AF_INET(%d), "
|
|
|
|
|
"AF_INET6(%d) ",
|
|
|
|
|
family, AF_UNSPEC,
|
|
|
|
|
AF_INET, AF_INET6);
|
|
|
|
|
family = AF_UNSPEC;
|
|
|
|
|
}
|
|
|
|
|
} else if (!strcmp(sgwc_key,
|
|
|
|
|
"address")) {
|
|
|
|
|
ogs_yaml_iter_t hostname_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&sgwc_iter,
|
|
|
|
|
&hostname_iter);
|
|
|
|
|
ogs_assert(ogs_yaml_iter_type(
|
|
|
|
|
&hostname_iter) !=
|
|
|
|
|
YAML_MAPPING_NODE);
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
if (ogs_yaml_iter_type(
|
|
|
|
|
&hostname_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE) {
|
|
|
|
|
if (!ogs_yaml_iter_next(
|
|
|
|
|
&hostname_iter))
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ogs_assert(num <
|
|
|
|
|
OGS_MAX_NUM_OF_HOSTNAME);
|
|
|
|
|
hostname[num++] =
|
|
|
|
|
ogs_yaml_iter_value(
|
|
|
|
|
&hostname_iter);
|
|
|
|
|
} while (
|
|
|
|
|
ogs_yaml_iter_type(
|
|
|
|
|
&hostname_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
|
|
|
|
} else if (!strcmp(sgwc_key,
|
|
|
|
|
"port")) {
|
|
|
|
|
const char *v =
|
|
|
|
|
ogs_yaml_iter_value(
|
|
|
|
|
&sgwc_iter);
|
|
|
|
|
if (v) port = atoi(v);
|
|
|
|
|
} else if (!strcmp(
|
|
|
|
|
sgwc_key, "tac")) {
|
|
|
|
|
ogs_yaml_iter_t tac_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&sgwc_iter, &tac_iter);
|
|
|
|
|
ogs_assert(ogs_yaml_iter_type(
|
|
|
|
|
&tac_iter) !=
|
|
|
|
|
YAML_MAPPING_NODE);
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
const char *v = NULL;
|
|
|
|
|
|
|
|
|
|
if (ogs_yaml_iter_type(
|
|
|
|
|
&tac_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE) {
|
|
|
|
|
if (!ogs_yaml_iter_next(
|
|
|
|
|
&tac_iter))
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2023-12-03 14:52:29 +00:00
|
|
|
ogs_assert(num_of_tac <
|
|
|
|
|
OGS_MAX_NUM_OF_TAI);
|
2023-11-19 10:34:51 +00:00
|
|
|
v = ogs_yaml_iter_value(
|
|
|
|
|
&tac_iter);
|
|
|
|
|
if (v) {
|
|
|
|
|
tac[num_of_tac] =
|
|
|
|
|
atoi(v);
|
|
|
|
|
num_of_tac++;
|
|
|
|
|
}
|
|
|
|
|
} while (
|
|
|
|
|
ogs_yaml_iter_type(
|
|
|
|
|
&tac_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
|
|
|
|
} else if (!strcmp(sgwc_key,
|
|
|
|
|
"e_cell_id")) {
|
|
|
|
|
ogs_yaml_iter_t e_cell_id_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&sgwc_iter,
|
|
|
|
|
&e_cell_id_iter);
|
|
|
|
|
ogs_assert(ogs_yaml_iter_type(
|
|
|
|
|
&e_cell_id_iter) !=
|
|
|
|
|
YAML_MAPPING_NODE);
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
const char *v = NULL;
|
|
|
|
|
|
|
|
|
|
if (ogs_yaml_iter_type(
|
|
|
|
|
&e_cell_id_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE) {
|
|
|
|
|
if (!ogs_yaml_iter_next(
|
|
|
|
|
&e_cell_id_iter))
|
|
|
|
|
break;
|
|
|
|
|
}
|
2023-12-03 14:52:29 +00:00
|
|
|
ogs_assert(
|
|
|
|
|
num_of_e_cell_id <
|
|
|
|
|
OGS_MAX_NUM_OF_CELL_ID);
|
2023-11-19 10:34:51 +00:00
|
|
|
v = ogs_yaml_iter_value(
|
|
|
|
|
&e_cell_id_iter);
|
|
|
|
|
if (v) {
|
|
|
|
|
e_cell_id[
|
|
|
|
|
num_of_e_cell_id] =
|
|
|
|
|
ogs_uint64_from_string(
|
|
|
|
|
(char*)v);
|
|
|
|
|
num_of_e_cell_id++;
|
|
|
|
|
}
|
|
|
|
|
} while (ogs_yaml_iter_type(
|
|
|
|
|
&e_cell_id_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
|
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown key `%s`",
|
|
|
|
|
sgwc_key);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
addr = NULL;
|
|
|
|
|
for (i = 0; i < num; i++) {
|
|
|
|
|
rv = ogs_addaddrinfo(&addr, family,
|
|
|
|
|
hostname[i], port, 0);
|
|
|
|
|
ogs_assert(rv == OGS_OK);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ogs_filter_ip_version(&addr,
|
|
|
|
|
ogs_global_conf()->parameter.
|
|
|
|
|
no_ipv4,
|
|
|
|
|
ogs_global_conf()->parameter.
|
|
|
|
|
no_ipv6,
|
|
|
|
|
ogs_global_conf()->parameter.
|
|
|
|
|
prefer_ipv4);
|
|
|
|
|
|
|
|
|
|
if (addr == NULL) continue;
|
|
|
|
|
|
|
|
|
|
sgw = mme_sgw_add(addr);
|
|
|
|
|
ogs_assert(sgw);
|
|
|
|
|
|
|
|
|
|
sgw->num_of_tac = num_of_tac;
|
|
|
|
|
if (num_of_tac != 0)
|
|
|
|
|
memcpy(sgw->tac,
|
|
|
|
|
tac, sizeof(sgw->tac));
|
|
|
|
|
|
|
|
|
|
sgw->num_of_e_cell_id =
|
|
|
|
|
num_of_e_cell_id;
|
|
|
|
|
if (num_of_e_cell_id != 0)
|
|
|
|
|
memcpy(sgw->e_cell_id, e_cell_id,
|
|
|
|
|
sizeof(sgw->e_cell_id));
|
|
|
|
|
|
|
|
|
|
} while (ogs_yaml_iter_type(&sgwc_array) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
|
|
|
|
|
|
|
|
|
} else if (!strcmp(client_key, "smf")) {
|
|
|
|
|
ogs_yaml_iter_t smf_array, smf_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&client_iter, &smf_array);
|
|
|
|
|
do {
|
|
|
|
|
mme_pgw_t *pgw = NULL;
|
|
|
|
|
ogs_sockaddr_t *addr = NULL;
|
|
|
|
|
int family = AF_UNSPEC;
|
|
|
|
|
int i, num = 0;
|
|
|
|
|
const char *hostname[
|
|
|
|
|
OGS_MAX_NUM_OF_HOSTNAME];
|
|
|
|
|
uint16_t port =
|
|
|
|
|
ogs_gtp_self()->gtpc_port;
|
|
|
|
|
const char *apn[
|
|
|
|
|
OGS_MAX_NUM_OF_APN] = {NULL,};
|
|
|
|
|
uint8_t num_of_apn = 0;
|
|
|
|
|
uint16_t tac[OGS_MAX_NUM_OF_TAI] = {0,};
|
|
|
|
|
uint8_t num_of_tac = 0;
|
|
|
|
|
uint32_t e_cell_id[
|
|
|
|
|
OGS_MAX_NUM_OF_CELL_ID] = {0,};
|
|
|
|
|
uint8_t num_of_e_cell_id = 0;
|
|
|
|
|
|
|
|
|
|
if (ogs_yaml_iter_type(&smf_array) ==
|
|
|
|
|
YAML_MAPPING_NODE) {
|
|
|
|
|
memcpy(&smf_iter, &smf_array,
|
|
|
|
|
sizeof(ogs_yaml_iter_t));
|
|
|
|
|
} else if (ogs_yaml_iter_type(
|
|
|
|
|
&smf_array) ==
|
2019-05-18 15:24:15 +00:00
|
|
|
YAML_SEQUENCE_NODE) {
|
2023-11-19 10:34:51 +00:00
|
|
|
if (!ogs_yaml_iter_next(&smf_array))
|
|
|
|
|
break;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&smf_array, &smf_iter);
|
|
|
|
|
} else if (ogs_yaml_iter_type(
|
|
|
|
|
&smf_array) ==
|
|
|
|
|
YAML_SCALAR_NODE) {
|
2017-12-08 03:43:35 +00:00
|
|
|
break;
|
2023-11-19 10:34:51 +00:00
|
|
|
} else
|
|
|
|
|
ogs_assert_if_reached();
|
|
|
|
|
|
|
|
|
|
while (ogs_yaml_iter_next(&smf_iter)) {
|
|
|
|
|
const char *smf_key =
|
|
|
|
|
ogs_yaml_iter_key(&smf_iter);
|
|
|
|
|
ogs_assert(smf_key);
|
|
|
|
|
if (!strcmp(smf_key, "family")) {
|
|
|
|
|
const char *v =
|
|
|
|
|
ogs_yaml_iter_value(
|
|
|
|
|
&smf_iter);
|
|
|
|
|
if (v) family = atoi(v);
|
|
|
|
|
if (family != AF_UNSPEC &&
|
|
|
|
|
family != AF_INET &&
|
|
|
|
|
family != AF_INET6) {
|
|
|
|
|
ogs_warn(
|
|
|
|
|
"Ignore family(%d) : "
|
|
|
|
|
"AF_UNSPEC(%d), "
|
|
|
|
|
"AF_INET(%d), "
|
|
|
|
|
"AF_INET6(%d) ",
|
|
|
|
|
family, AF_UNSPEC,
|
|
|
|
|
AF_INET, AF_INET6);
|
|
|
|
|
family = AF_UNSPEC;
|
|
|
|
|
}
|
|
|
|
|
} else if (!strcmp(smf_key,
|
|
|
|
|
"address")) {
|
|
|
|
|
ogs_yaml_iter_t hostname_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&smf_iter,
|
|
|
|
|
&hostname_iter);
|
|
|
|
|
ogs_assert(ogs_yaml_iter_type(
|
|
|
|
|
&hostname_iter) !=
|
|
|
|
|
YAML_MAPPING_NODE);
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
if (ogs_yaml_iter_type(
|
|
|
|
|
&hostname_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE) {
|
|
|
|
|
if (!ogs_yaml_iter_next(
|
|
|
|
|
&hostname_iter))
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ogs_assert(num <
|
|
|
|
|
OGS_MAX_NUM_OF_HOSTNAME);
|
|
|
|
|
hostname[num++] =
|
|
|
|
|
ogs_yaml_iter_value(
|
|
|
|
|
&hostname_iter);
|
|
|
|
|
} while (ogs_yaml_iter_type(
|
|
|
|
|
&hostname_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
|
|
|
|
} else if (!strcmp(
|
|
|
|
|
smf_key, "port")) {
|
|
|
|
|
const char *v =
|
|
|
|
|
ogs_yaml_iter_value(
|
|
|
|
|
&smf_iter);
|
|
|
|
|
if (v) port = atoi(v);
|
|
|
|
|
} else if (!strcmp(
|
|
|
|
|
smf_key, "apn")) {
|
|
|
|
|
ogs_yaml_iter_t apn_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&smf_iter, &apn_iter);
|
|
|
|
|
ogs_assert(ogs_yaml_iter_type(
|
|
|
|
|
&apn_iter) !=
|
|
|
|
|
YAML_MAPPING_NODE);
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
const char *v = NULL;
|
|
|
|
|
|
|
|
|
|
if (ogs_yaml_iter_type(
|
|
|
|
|
&apn_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE) {
|
|
|
|
|
if (!ogs_yaml_iter_next(
|
|
|
|
|
&apn_iter))
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2023-12-03 14:52:29 +00:00
|
|
|
ogs_assert(num_of_apn <
|
|
|
|
|
OGS_MAX_NUM_OF_APN);
|
2023-11-19 10:34:51 +00:00
|
|
|
v = ogs_yaml_iter_value(
|
|
|
|
|
&apn_iter);
|
|
|
|
|
if (v) {
|
|
|
|
|
apn[num_of_apn] = v;
|
|
|
|
|
num_of_apn++;
|
|
|
|
|
}
|
|
|
|
|
} while (ogs_yaml_iter_type(
|
|
|
|
|
&apn_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
|
|
|
|
} else if (!strcmp(
|
|
|
|
|
smf_key, "tac")) {
|
|
|
|
|
ogs_yaml_iter_t tac_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&smf_iter, &tac_iter);
|
|
|
|
|
ogs_assert(ogs_yaml_iter_type(
|
|
|
|
|
&tac_iter) !=
|
|
|
|
|
YAML_MAPPING_NODE);
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
const char *v = NULL;
|
|
|
|
|
|
|
|
|
|
if (ogs_yaml_iter_type(
|
|
|
|
|
&tac_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE) {
|
|
|
|
|
if (!ogs_yaml_iter_next(
|
|
|
|
|
&tac_iter))
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2023-12-03 14:52:29 +00:00
|
|
|
ogs_assert(num_of_tac <
|
|
|
|
|
OGS_MAX_NUM_OF_TAI);
|
2023-11-19 10:34:51 +00:00
|
|
|
v = ogs_yaml_iter_value(
|
|
|
|
|
&tac_iter);
|
|
|
|
|
if (v) {
|
|
|
|
|
tac[num_of_tac] =
|
|
|
|
|
atoi(v);
|
|
|
|
|
num_of_tac++;
|
|
|
|
|
}
|
|
|
|
|
} while (ogs_yaml_iter_type(
|
|
|
|
|
&tac_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
|
|
|
|
} else if (!strcmp(smf_key,
|
|
|
|
|
"e_cell_id")) {
|
|
|
|
|
ogs_yaml_iter_t e_cell_id_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&smf_iter,
|
|
|
|
|
&e_cell_id_iter);
|
|
|
|
|
ogs_assert(ogs_yaml_iter_type(
|
|
|
|
|
&e_cell_id_iter) !=
|
|
|
|
|
YAML_MAPPING_NODE);
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
const char *v = NULL;
|
|
|
|
|
|
|
|
|
|
if (ogs_yaml_iter_type(
|
|
|
|
|
&e_cell_id_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE) {
|
|
|
|
|
if (!ogs_yaml_iter_next(
|
|
|
|
|
&e_cell_id_iter))
|
|
|
|
|
break;
|
|
|
|
|
}
|
2023-12-03 14:52:29 +00:00
|
|
|
ogs_assert(
|
|
|
|
|
num_of_e_cell_id <
|
|
|
|
|
OGS_MAX_NUM_OF_CELL_ID);
|
2023-11-19 10:34:51 +00:00
|
|
|
v = ogs_yaml_iter_value(
|
|
|
|
|
&e_cell_id_iter);
|
|
|
|
|
if (v) {
|
|
|
|
|
e_cell_id[
|
|
|
|
|
num_of_e_cell_id] =
|
|
|
|
|
ogs_uint64_from_string(
|
|
|
|
|
(char*)v);
|
|
|
|
|
num_of_e_cell_id++;
|
|
|
|
|
}
|
|
|
|
|
} while (ogs_yaml_iter_type(
|
|
|
|
|
&e_cell_id_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
|
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown key `%s`",
|
|
|
|
|
smf_key);
|
|
|
|
|
}
|
2017-12-08 03:43:35 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
addr = NULL;
|
|
|
|
|
for (i = 0; i < num; i++) {
|
|
|
|
|
rv = ogs_addaddrinfo(&addr, family,
|
|
|
|
|
hostname[i], port, 0);
|
|
|
|
|
ogs_assert(rv == OGS_OK);
|
|
|
|
|
}
|
2017-11-24 15:52:07 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_filter_ip_version(&addr,
|
|
|
|
|
ogs_global_conf()->parameter.
|
|
|
|
|
no_ipv4,
|
|
|
|
|
ogs_global_conf()->parameter.
|
|
|
|
|
no_ipv6,
|
|
|
|
|
ogs_global_conf()->parameter.
|
|
|
|
|
prefer_ipv4);
|
2017-12-08 03:43:35 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
if (addr == NULL) continue;
|
2017-12-08 03:43:35 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
pgw = mme_pgw_add(addr);
|
|
|
|
|
ogs_assert(pgw);
|
2017-12-08 03:43:35 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
pgw->num_of_apn = num_of_apn;
|
|
|
|
|
if (num_of_apn != 0)
|
|
|
|
|
memcpy(pgw->apn,
|
|
|
|
|
apn, sizeof(pgw->apn));
|
|
|
|
|
|
|
|
|
|
pgw->num_of_tac = num_of_tac;
|
|
|
|
|
if (num_of_tac != 0)
|
|
|
|
|
memcpy(pgw->tac,
|
|
|
|
|
tac, sizeof(pgw->tac));
|
|
|
|
|
|
|
|
|
|
pgw->num_of_e_cell_id =
|
|
|
|
|
num_of_e_cell_id;
|
|
|
|
|
if (num_of_e_cell_id != 0)
|
|
|
|
|
memcpy(pgw->e_cell_id, e_cell_id,
|
|
|
|
|
sizeof(pgw->e_cell_id));
|
|
|
|
|
|
|
|
|
|
} while (ogs_yaml_iter_type(&smf_array) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
|
|
|
|
} else if (!strcmp(client_key, "sgsn")) {
|
|
|
|
|
ogs_yaml_iter_t sgsn_array, sgsn_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&client_iter,
|
|
|
|
|
&sgsn_array);
|
|
|
|
|
ogs_assert(ogs_yaml_iter_type(
|
|
|
|
|
&sgsn_array) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
|
|
|
|
do {
|
|
|
|
|
mme_sgsn_t *sgsn = NULL;
|
|
|
|
|
|
|
|
|
|
ogs_sockaddr_t *addr = NULL;
|
|
|
|
|
int family = AF_UNSPEC;
|
|
|
|
|
int i, num = 0;
|
|
|
|
|
const char *hostname[
|
|
|
|
|
OGS_MAX_NUM_OF_HOSTNAME];
|
|
|
|
|
uint16_t port =
|
|
|
|
|
ogs_gtp_self()->gtpc_port;
|
|
|
|
|
|
|
|
|
|
OGS_LIST(route_list);
|
|
|
|
|
bool default_route = false;
|
|
|
|
|
|
|
|
|
|
if (ogs_yaml_iter_type(&sgsn_array) ==
|
|
|
|
|
YAML_MAPPING_NODE) {
|
|
|
|
|
memcpy(&sgsn_iter, &sgsn_array,
|
|
|
|
|
sizeof(ogs_yaml_iter_t));
|
|
|
|
|
} else if (ogs_yaml_iter_type(
|
|
|
|
|
&sgsn_array) ==
|
|
|
|
|
YAML_SEQUENCE_NODE) {
|
|
|
|
|
if (!ogs_yaml_iter_next(
|
|
|
|
|
&sgsn_array))
|
|
|
|
|
break;
|
|
|
|
|
ogs_yaml_iter_recurse(&sgsn_array,
|
|
|
|
|
&sgsn_iter);
|
|
|
|
|
} else if (ogs_yaml_iter_type(
|
|
|
|
|
&sgsn_array) ==
|
|
|
|
|
YAML_SCALAR_NODE) {
|
|
|
|
|
break;
|
|
|
|
|
} else
|
|
|
|
|
ogs_assert_if_reached();
|
|
|
|
|
|
|
|
|
|
while (ogs_yaml_iter_next(&sgsn_iter)) {
|
|
|
|
|
const char *sgsn_key =
|
|
|
|
|
ogs_yaml_iter_key(&sgsn_iter);
|
|
|
|
|
ogs_assert(sgsn_key);
|
|
|
|
|
if (!strcmp(sgsn_key, "family")) {
|
|
|
|
|
const char *v =
|
|
|
|
|
ogs_yaml_iter_value(
|
|
|
|
|
&sgsn_iter);
|
|
|
|
|
if (v) family = atoi(v);
|
|
|
|
|
if (family != AF_UNSPEC &&
|
|
|
|
|
family != AF_INET &&
|
|
|
|
|
family != AF_INET6) {
|
|
|
|
|
ogs_warn("Ignore family(%d)"
|
|
|
|
|
": AF_UNSPEC(%d), "
|
|
|
|
|
"AF_INET(%d), "
|
|
|
|
|
"AF_INET6(%d) ",
|
|
|
|
|
family, AF_UNSPEC,
|
|
|
|
|
AF_INET, AF_INET6);
|
|
|
|
|
family = AF_UNSPEC;
|
|
|
|
|
}
|
|
|
|
|
} else if (!strcmp(sgsn_key,
|
|
|
|
|
"address")) {
|
|
|
|
|
ogs_yaml_iter_t hostname_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&sgsn_iter,
|
|
|
|
|
&hostname_iter);
|
|
|
|
|
ogs_assert(ogs_yaml_iter_type(
|
|
|
|
|
&hostname_iter) !=
|
|
|
|
|
YAML_MAPPING_NODE);
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
if (ogs_yaml_iter_type(
|
|
|
|
|
&hostname_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE) {
|
|
|
|
|
if (!ogs_yaml_iter_next(
|
|
|
|
|
&hostname_iter))
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ogs_assert(num <
|
|
|
|
|
OGS_MAX_NUM_OF_HOSTNAME);
|
|
|
|
|
hostname[num++] =
|
|
|
|
|
ogs_yaml_iter_value(
|
|
|
|
|
&hostname_iter);
|
|
|
|
|
} while (
|
|
|
|
|
ogs_yaml_iter_type(
|
|
|
|
|
&hostname_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
|
|
|
|
} else if (!strcmp(sgsn_key,
|
|
|
|
|
"port")) {
|
|
|
|
|
const char *v =
|
|
|
|
|
ogs_yaml_iter_value(
|
|
|
|
|
&sgsn_iter);
|
|
|
|
|
if (v) port = atoi(v);
|
|
|
|
|
} else if (!strcmp(sgsn_key,
|
|
|
|
|
"routes")) {
|
|
|
|
|
ogs_yaml_iter_t routes_array;
|
|
|
|
|
ogs_yaml_iter_t routes_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&sgsn_iter,
|
|
|
|
|
&routes_array);
|
|
|
|
|
do {
|
|
|
|
|
ogs_nas_rai_t rai;
|
|
|
|
|
uint16_t cell_id = 0;
|
|
|
|
|
bool rai_parsed = false;
|
|
|
|
|
bool cell_id_parsed = false;
|
|
|
|
|
mme_sgsn_route_t *sgsn_rt =
|
|
|
|
|
NULL;
|
|
|
|
|
|
|
|
|
|
if (ogs_yaml_iter_type(
|
|
|
|
|
&routes_array) ==
|
|
|
|
|
YAML_MAPPING_NODE) {
|
|
|
|
|
memcpy(&routes_iter,
|
|
|
|
|
&routes_array,
|
|
|
|
|
sizeof(
|
|
|
|
|
ogs_yaml_iter_t));
|
|
|
|
|
} else if (
|
|
|
|
|
ogs_yaml_iter_type(
|
|
|
|
|
&routes_array) ==
|
|
|
|
|
YAML_SEQUENCE_NODE) {
|
|
|
|
|
if (!ogs_yaml_iter_next(
|
|
|
|
|
&routes_array))
|
|
|
|
|
break;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&routes_array,
|
|
|
|
|
&routes_iter);
|
|
|
|
|
} else if (
|
|
|
|
|
ogs_yaml_iter_type(
|
|
|
|
|
&routes_array) ==
|
|
|
|
|
YAML_SCALAR_NODE) {
|
|
|
|
|
break;
|
|
|
|
|
} else
|
|
|
|
|
ogs_assert_if_reached();
|
|
|
|
|
|
|
|
|
|
while (ogs_yaml_iter_next(
|
|
|
|
|
&routes_iter)) {
|
|
|
|
|
const char *routes_key =
|
|
|
|
|
ogs_yaml_iter_key(
|
|
|
|
|
&routes_iter);
|
|
|
|
|
ogs_assert(routes_key);
|
|
|
|
|
if (!strcmp(routes_key,
|
|
|
|
|
"rai")) {
|
|
|
|
|
memset(&rai, 0,
|
|
|
|
|
sizeof(rai));
|
|
|
|
|
rv = parse_rai(
|
|
|
|
|
&routes_iter,
|
|
|
|
|
&rai);
|
|
|
|
|
ogs_assert(rv ==
|
|
|
|
|
OGS_OK);
|
|
|
|
|
rai_parsed = true;
|
|
|
|
|
} else if (!strcmp(
|
|
|
|
|
routes_key,
|
|
|
|
|
"ci")) {
|
|
|
|
|
ogs_yaml_iter_t cell_id_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&routes_iter, &cell_id_iter);
|
|
|
|
|
ogs_assert(ogs_yaml_iter_type(
|
|
|
|
|
&cell_id_iter) !=
|
|
|
|
|
YAML_MAPPING_NODE);
|
|
|
|
|
do {
|
|
|
|
|
const char *v = NULL;
|
|
|
|
|
|
|
|
|
|
if (ogs_yaml_iter_type(
|
|
|
|
|
&cell_id_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE) {
|
|
|
|
|
if (!ogs_yaml_iter_next(
|
|
|
|
|
&cell_id_iter))
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
v = ogs_yaml_iter_value(
|
|
|
|
|
&cell_id_iter);
|
|
|
|
|
if (v) {
|
|
|
|
|
cell_id = atoi((char*)v);
|
|
|
|
|
cell_id_parsed = true;
|
|
|
|
|
}
|
|
|
|
|
} while (
|
|
|
|
|
ogs_yaml_iter_type(&cell_id_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
|
|
|
|
|
|
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown "
|
|
|
|
|
"key `%s`",
|
|
|
|
|
routes_key);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ogs_assert(rai_parsed &&
|
|
|
|
|
cell_id_parsed);
|
|
|
|
|
ogs_pool_alloc(
|
|
|
|
|
&mme_sgsn_route_pool,
|
|
|
|
|
&sgsn_rt);
|
|
|
|
|
ogs_assert(sgsn_rt);
|
|
|
|
|
memcpy(&sgsn_rt->rai, &rai,
|
|
|
|
|
sizeof(rai));
|
|
|
|
|
sgsn_rt->cell_id = cell_id;
|
|
|
|
|
ogs_list_add(&route_list,
|
|
|
|
|
sgsn_rt);
|
|
|
|
|
|
|
|
|
|
} while (ogs_yaml_iter_type(
|
|
|
|
|
&routes_array) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
|
|
|
|
} else if (!strcmp(sgsn_key,
|
|
|
|
|
"default_route")) {
|
|
|
|
|
default_route = true;
|
|
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown key `%s`",
|
|
|
|
|
sgsn_key);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
addr = NULL;
|
|
|
|
|
for (i = 0; i < num; i++) {
|
|
|
|
|
rv = ogs_addaddrinfo(&addr,
|
|
|
|
|
family, hostname[i], port,
|
|
|
|
|
0);
|
|
|
|
|
ogs_assert(rv == OGS_OK);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ogs_filter_ip_version(&addr,
|
|
|
|
|
ogs_global_conf()->parameter.
|
|
|
|
|
no_ipv4,
|
|
|
|
|
ogs_global_conf()->parameter.
|
|
|
|
|
no_ipv6,
|
|
|
|
|
ogs_global_conf()->parameter.
|
|
|
|
|
prefer_ipv4);
|
|
|
|
|
|
|
|
|
|
if (addr == NULL) continue;
|
2017-12-08 03:43:35 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
sgsn = mme_sgsn_add(addr);
|
|
|
|
|
ogs_assert(sgsn);
|
|
|
|
|
|
|
|
|
|
if (ogs_list_count(&route_list))
|
|
|
|
|
ogs_list_copy(&sgsn->route_list,
|
|
|
|
|
&route_list);
|
|
|
|
|
|
|
|
|
|
sgsn->default_route = default_route;
|
|
|
|
|
|
|
|
|
|
} while (ogs_yaml_iter_type(&sgsn_array) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
|
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown key `%s`", client_key);
|
|
|
|
|
}
|
|
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown key `%s`", gtpc_key);
|
2017-12-08 03:43:35 +00:00
|
|
|
}
|
2019-06-02 02:09:01 +00:00
|
|
|
} else if (!strcmp(mme_key, "gummei")) {
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_t gummei_array, gummei_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&mme_iter, &gummei_array);
|
2019-05-18 15:24:15 +00:00
|
|
|
do {
|
2017-11-08 15:05:18 +00:00
|
|
|
served_gummei_t *gummei = NULL;
|
2017-11-29 00:41:29 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
if (ogs_yaml_iter_type(&gummei_array) ==
|
2019-05-18 15:24:15 +00:00
|
|
|
YAML_MAPPING_NODE) {
|
2017-11-29 00:41:29 +00:00
|
|
|
memcpy(&gummei_iter, &gummei_array,
|
2019-04-27 14:54:30 +00:00
|
|
|
sizeof(ogs_yaml_iter_t));
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (ogs_yaml_iter_type(&gummei_array) ==
|
2019-05-18 15:24:15 +00:00
|
|
|
YAML_SEQUENCE_NODE) {
|
2019-04-27 14:54:30 +00:00
|
|
|
if (!ogs_yaml_iter_next(&gummei_array))
|
2017-11-29 00:41:29 +00:00
|
|
|
break;
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_recurse(&gummei_array,
|
2017-11-29 00:41:29 +00:00
|
|
|
&gummei_iter);
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (ogs_yaml_iter_type(&gummei_array) ==
|
2019-05-18 15:24:15 +00:00
|
|
|
YAML_SCALAR_NODE) {
|
2017-12-01 12:47:15 +00:00
|
|
|
break;
|
2019-05-29 12:27:22 +00:00
|
|
|
} else
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert_if_reached();
|
2017-11-29 00:41:29 +00:00
|
|
|
|
2023-12-03 14:52:29 +00:00
|
|
|
ogs_assert(self.num_of_served_gummei <
|
|
|
|
|
OGS_MAX_NUM_OF_SERVED_GUMMEI);
|
|
|
|
|
gummei = &self.served_gummei[
|
|
|
|
|
self.num_of_served_gummei];
|
|
|
|
|
ogs_assert(gummei);
|
|
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
while (ogs_yaml_iter_next(&gummei_iter)) {
|
2017-11-08 15:05:18 +00:00
|
|
|
const char *gummei_key =
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_key(&gummei_iter);
|
|
|
|
|
ogs_assert(gummei_key);
|
2019-05-18 15:24:15 +00:00
|
|
|
if (!strcmp(gummei_key, "plmn_id")) {
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_t plmn_id_array, plmn_id_iter;
|
2019-05-18 15:24:15 +00:00
|
|
|
ogs_yaml_iter_recurse(&gummei_iter,
|
|
|
|
|
&plmn_id_array);
|
|
|
|
|
do {
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_plmn_id_t *plmn_id = NULL;
|
2017-11-08 15:05:18 +00:00
|
|
|
const char *mcc = NULL, *mnc = NULL;
|
2017-11-29 00:41:29 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
if (ogs_yaml_iter_type(&plmn_id_array) ==
|
2019-05-18 15:24:15 +00:00
|
|
|
YAML_MAPPING_NODE) {
|
2017-11-29 00:41:29 +00:00
|
|
|
memcpy(&plmn_id_iter, &plmn_id_array,
|
2019-04-27 14:54:30 +00:00
|
|
|
sizeof(ogs_yaml_iter_t));
|
2020-04-27 02:18:47 +00:00
|
|
|
} else if (ogs_yaml_iter_type(
|
|
|
|
|
&plmn_id_array) ==
|
|
|
|
|
YAML_SEQUENCE_NODE) {
|
2019-04-27 14:54:30 +00:00
|
|
|
if (!ogs_yaml_iter_next(&plmn_id_array))
|
2017-11-29 00:41:29 +00:00
|
|
|
break;
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_recurse(&plmn_id_array,
|
2017-11-29 00:41:29 +00:00
|
|
|
&plmn_id_iter);
|
2020-04-27 02:18:47 +00:00
|
|
|
} else if (ogs_yaml_iter_type(
|
|
|
|
|
&plmn_id_array) ==
|
|
|
|
|
YAML_SCALAR_NODE) {
|
2017-12-01 12:47:15 +00:00
|
|
|
break;
|
2019-05-29 12:27:22 +00:00
|
|
|
} else
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert_if_reached();
|
2017-11-08 15:05:18 +00:00
|
|
|
|
2023-12-03 14:52:29 +00:00
|
|
|
ogs_assert(gummei->num_of_plmn_id <
|
|
|
|
|
OGS_MAX_NUM_OF_PLMN_PER_MME);
|
|
|
|
|
plmn_id = &gummei->plmn_id[
|
|
|
|
|
gummei->num_of_plmn_id];
|
|
|
|
|
ogs_assert(plmn_id);
|
|
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
while (ogs_yaml_iter_next(&plmn_id_iter)) {
|
2017-11-29 00:41:29 +00:00
|
|
|
const char *plmn_id_key =
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_key(&plmn_id_iter);
|
|
|
|
|
ogs_assert(plmn_id_key);
|
2023-03-25 00:18:20 +00:00
|
|
|
if (!strcmp(plmn_id_key, "mcc")) {
|
2019-05-18 15:24:15 +00:00
|
|
|
mcc = ogs_yaml_iter_value(
|
|
|
|
|
&plmn_id_iter);
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (!strcmp(
|
|
|
|
|
plmn_id_key, "mnc")) {
|
2019-05-18 15:24:15 +00:00
|
|
|
mnc = ogs_yaml_iter_value(
|
|
|
|
|
&plmn_id_iter);
|
2017-07-14 15:00:08 +00:00
|
|
|
}
|
|
|
|
|
}
|
2017-11-29 00:41:29 +00:00
|
|
|
|
2019-05-18 15:24:15 +00:00
|
|
|
if (mcc && mnc) {
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_plmn_id_build(plmn_id,
|
2017-11-29 00:41:29 +00:00
|
|
|
atoi(mcc), atoi(mnc), strlen(mnc));
|
2017-07-14 15:00:08 +00:00
|
|
|
gummei->num_of_plmn_id++;
|
|
|
|
|
}
|
2017-11-29 00:41:29 +00:00
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
} while (ogs_yaml_iter_type(&plmn_id_array) ==
|
2017-11-29 00:41:29 +00:00
|
|
|
YAML_SEQUENCE_NODE);
|
2019-06-02 12:55:24 +00:00
|
|
|
} else if (!strcmp(gummei_key, "mme_gid")) {
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_t mme_gid_iter;
|
2020-04-27 02:18:47 +00:00
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&gummei_iter, &mme_gid_iter);
|
|
|
|
|
ogs_assert(ogs_yaml_iter_type(
|
|
|
|
|
&mme_gid_iter) != YAML_MAPPING_NODE);
|
2017-11-08 15:05:18 +00:00
|
|
|
|
2019-05-18 15:24:15 +00:00
|
|
|
do {
|
2019-04-27 14:54:30 +00:00
|
|
|
uint16_t *mme_gid = NULL;
|
2017-11-29 00:41:29 +00:00
|
|
|
const char *v = NULL;
|
2017-11-08 15:05:18 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
if (ogs_yaml_iter_type(&mme_gid_iter) ==
|
2019-05-18 15:24:15 +00:00
|
|
|
YAML_SEQUENCE_NODE) {
|
2019-04-27 14:54:30 +00:00
|
|
|
if (!ogs_yaml_iter_next(&mme_gid_iter))
|
2017-11-29 00:41:29 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2023-12-03 14:52:29 +00:00
|
|
|
ogs_assert(gummei->num_of_mme_gid <
|
|
|
|
|
GRP_PER_MME);
|
|
|
|
|
mme_gid = &gummei->mme_gid[
|
|
|
|
|
gummei->num_of_mme_gid];
|
|
|
|
|
ogs_assert(mme_gid);
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
v = ogs_yaml_iter_value(&mme_gid_iter);
|
2019-05-18 15:24:15 +00:00
|
|
|
if (v) {
|
2017-11-29 00:41:29 +00:00
|
|
|
*mme_gid = atoi(v);
|
|
|
|
|
gummei->num_of_mme_gid++;
|
|
|
|
|
}
|
2019-05-29 12:27:22 +00:00
|
|
|
} while (
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_type(&mme_gid_iter) ==
|
2017-11-29 00:41:29 +00:00
|
|
|
YAML_SEQUENCE_NODE);
|
2019-06-02 02:09:01 +00:00
|
|
|
} else if (!strcmp(gummei_key, "mme_code")) {
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_t mme_code_iter;
|
2019-05-18 15:24:15 +00:00
|
|
|
ogs_yaml_iter_recurse(&gummei_iter,
|
|
|
|
|
&mme_code_iter);
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(ogs_yaml_iter_type(&mme_code_iter) !=
|
|
|
|
|
YAML_MAPPING_NODE);
|
2017-11-08 15:05:18 +00:00
|
|
|
|
2019-05-18 15:24:15 +00:00
|
|
|
do {
|
2019-04-27 14:54:30 +00:00
|
|
|
uint8_t *mme_code = NULL;
|
2017-11-29 00:41:29 +00:00
|
|
|
const char *v = NULL;
|
2017-11-08 15:05:18 +00:00
|
|
|
|
2021-03-08 12:25:09 +00:00
|
|
|
ogs_assert(gummei->num_of_mme_code <
|
2019-04-27 14:54:30 +00:00
|
|
|
CODE_PER_MME);
|
2017-11-29 00:41:29 +00:00
|
|
|
mme_code = &gummei->mme_code[
|
|
|
|
|
gummei->num_of_mme_code];
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(mme_code);
|
2017-11-29 00:41:29 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
if (ogs_yaml_iter_type(&mme_code_iter) ==
|
2019-05-18 15:24:15 +00:00
|
|
|
YAML_SEQUENCE_NODE) {
|
2019-04-27 14:54:30 +00:00
|
|
|
if (!ogs_yaml_iter_next(&mme_code_iter))
|
2017-11-29 00:41:29 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
v = ogs_yaml_iter_value(&mme_code_iter);
|
2019-05-18 15:24:15 +00:00
|
|
|
if (v) {
|
2017-11-29 00:41:29 +00:00
|
|
|
*mme_code = atoi(v);
|
|
|
|
|
gummei->num_of_mme_code++;
|
|
|
|
|
}
|
2019-05-29 12:27:22 +00:00
|
|
|
} while (
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_type(&mme_code_iter) ==
|
2017-11-29 00:41:29 +00:00
|
|
|
YAML_SEQUENCE_NODE);
|
2019-05-29 12:27:22 +00:00
|
|
|
} else
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_warn("unknown key `%s`", gummei_key);
|
2017-07-14 10:00:26 +00:00
|
|
|
}
|
2017-11-29 00:41:29 +00:00
|
|
|
|
|
|
|
|
if (gummei->num_of_plmn_id &&
|
2019-05-18 15:24:15 +00:00
|
|
|
gummei->num_of_mme_gid && gummei->num_of_mme_code) {
|
2023-12-03 14:52:29 +00:00
|
|
|
self.num_of_served_gummei++;
|
2019-05-29 12:27:22 +00:00
|
|
|
} else {
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_warn("Ignore gummei : "
|
2017-11-29 00:41:29 +00:00
|
|
|
"plmn_id(%d), mme_gid(%d), mme_code(%d)",
|
|
|
|
|
gummei->num_of_plmn_id,
|
2020-04-27 02:18:47 +00:00
|
|
|
gummei->num_of_mme_gid,
|
|
|
|
|
gummei->num_of_mme_code);
|
2017-11-29 00:41:29 +00:00
|
|
|
gummei->num_of_plmn_id = 0;
|
|
|
|
|
gummei->num_of_mme_gid = 0;
|
|
|
|
|
gummei->num_of_mme_code = 0;
|
|
|
|
|
}
|
2019-05-29 12:27:22 +00:00
|
|
|
} while (ogs_yaml_iter_type(&gummei_array) ==
|
2017-11-29 00:41:29 +00:00
|
|
|
YAML_SEQUENCE_NODE);
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (!strcmp(mme_key, "tai")) {
|
2017-12-10 15:01:02 +00:00
|
|
|
int num_of_list0 = 0;
|
2023-03-19 09:25:59 +00:00
|
|
|
int num_of_list1 = 0;
|
2020-05-25 16:15:22 +00:00
|
|
|
ogs_eps_tai0_list_t *list0 = NULL;
|
2023-03-19 09:25:59 +00:00
|
|
|
ogs_eps_tai1_list_t *list1 = NULL;
|
2020-05-25 16:15:22 +00:00
|
|
|
ogs_eps_tai2_list_t *list2 = NULL;
|
2017-12-10 15:01:02 +00:00
|
|
|
|
2021-03-08 12:25:09 +00:00
|
|
|
ogs_assert(self.num_of_served_tai <
|
2023-12-03 14:52:29 +00:00
|
|
|
OGS_MAX_NUM_OF_SUPPORTED_TA);
|
2017-12-10 15:01:02 +00:00
|
|
|
list0 = &self.served_tai[self.num_of_served_tai].list0;
|
2023-03-19 09:25:59 +00:00
|
|
|
list1 = &self.served_tai[self.num_of_served_tai].list1;
|
2017-12-10 15:01:02 +00:00
|
|
|
list2 = &self.served_tai[self.num_of_served_tai].list2;
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_t tai_array, tai_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&mme_iter, &tai_array);
|
2019-05-18 15:24:15 +00:00
|
|
|
do {
|
2017-11-08 15:05:18 +00:00
|
|
|
const char *mcc = NULL, *mnc = NULL;
|
2017-12-10 15:01:02 +00:00
|
|
|
int num_of_tac = 0;
|
2023-03-19 09:25:59 +00:00
|
|
|
uint16_t start[OGS_MAX_NUM_OF_TAI];
|
|
|
|
|
uint16_t end[OGS_MAX_NUM_OF_TAI];
|
2017-11-08 15:05:18 +00:00
|
|
|
|
2019-05-18 15:24:15 +00:00
|
|
|
if (ogs_yaml_iter_type(&tai_array) ==
|
|
|
|
|
YAML_MAPPING_NODE) {
|
|
|
|
|
memcpy(&tai_iter, &tai_array,
|
|
|
|
|
sizeof(ogs_yaml_iter_t));
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (ogs_yaml_iter_type(&tai_array) ==
|
2019-05-18 15:24:15 +00:00
|
|
|
YAML_SEQUENCE_NODE) {
|
2019-04-27 14:54:30 +00:00
|
|
|
if (!ogs_yaml_iter_next(&tai_array))
|
2017-11-29 00:41:29 +00:00
|
|
|
break;
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_recurse(&tai_array,
|
2017-11-29 00:41:29 +00:00
|
|
|
&tai_iter);
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (ogs_yaml_iter_type(&tai_array) ==
|
2019-05-18 15:24:15 +00:00
|
|
|
YAML_SCALAR_NODE) {
|
2017-12-01 12:47:15 +00:00
|
|
|
break;
|
2019-05-29 12:27:22 +00:00
|
|
|
} else
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert_if_reached();
|
2017-11-08 15:05:18 +00:00
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
while (ogs_yaml_iter_next(&tai_iter)) {
|
2019-04-27 14:54:30 +00:00
|
|
|
const char *tai_key = ogs_yaml_iter_key(&tai_iter);
|
|
|
|
|
ogs_assert(tai_key);
|
2019-05-18 15:24:15 +00:00
|
|
|
if (!strcmp(tai_key, "plmn_id")) {
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_t plmn_id_iter;
|
2017-11-29 00:41:29 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_recurse(&tai_iter, &plmn_id_iter);
|
2019-05-29 12:27:22 +00:00
|
|
|
while (ogs_yaml_iter_next(&plmn_id_iter)) {
|
2017-11-08 15:05:18 +00:00
|
|
|
const char *plmn_id_key =
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_key(&plmn_id_iter);
|
|
|
|
|
ogs_assert(plmn_id_key);
|
2019-05-18 15:24:15 +00:00
|
|
|
if (!strcmp(plmn_id_key, "mcc")) {
|
|
|
|
|
mcc = ogs_yaml_iter_value(
|
|
|
|
|
&plmn_id_iter);
|
2019-06-02 02:09:01 +00:00
|
|
|
} else if (!strcmp(plmn_id_key, "mnc")) {
|
2019-05-18 15:24:15 +00:00
|
|
|
mnc = ogs_yaml_iter_value(
|
|
|
|
|
&plmn_id_iter);
|
2017-07-14 15:27:22 +00:00
|
|
|
}
|
|
|
|
|
}
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (!strcmp(tai_key, "tac")) {
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_t tac_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&tai_iter, &tac_iter);
|
|
|
|
|
ogs_assert(ogs_yaml_iter_type(&tac_iter) !=
|
2023-03-19 09:25:59 +00:00
|
|
|
YAML_MAPPING_NODE);
|
2019-05-18 15:24:15 +00:00
|
|
|
do {
|
2023-03-19 09:25:59 +00:00
|
|
|
char *v = NULL;
|
|
|
|
|
char *low = NULL, *high = NULL;
|
2017-12-10 15:01:02 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
if (ogs_yaml_iter_type(&tac_iter) ==
|
2019-05-18 15:24:15 +00:00
|
|
|
YAML_SEQUENCE_NODE) {
|
2019-04-27 14:54:30 +00:00
|
|
|
if (!ogs_yaml_iter_next(&tac_iter))
|
2017-12-10 15:01:02 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2023-03-19 09:25:59 +00:00
|
|
|
v = (char *)ogs_yaml_iter_value(
|
|
|
|
|
&tac_iter);
|
2019-05-18 15:24:15 +00:00
|
|
|
if (v) {
|
2023-03-19 09:25:59 +00:00
|
|
|
low = strsep(&v, "-");
|
|
|
|
|
if (low && strlen(low) == 0)
|
|
|
|
|
low = NULL;
|
|
|
|
|
|
|
|
|
|
high = v;
|
|
|
|
|
if (high && strlen(high) == 0)
|
|
|
|
|
high = NULL;
|
|
|
|
|
|
|
|
|
|
if (low) {
|
|
|
|
|
ogs_assert(num_of_tac <
|
|
|
|
|
OGS_MAX_NUM_OF_TAI);
|
|
|
|
|
start[num_of_tac] = atoi(low);
|
|
|
|
|
if (high) {
|
|
|
|
|
end[num_of_tac] = atoi(high);
|
|
|
|
|
if (end[num_of_tac] <
|
|
|
|
|
start[num_of_tac])
|
|
|
|
|
ogs_error(
|
|
|
|
|
"Invalid TAI range: "
|
|
|
|
|
"LOW:%s,HIGH:%s",
|
|
|
|
|
low, high);
|
|
|
|
|
else if (
|
|
|
|
|
(end[num_of_tac]-
|
|
|
|
|
start[num_of_tac]+1) >
|
|
|
|
|
OGS_MAX_NUM_OF_TAI)
|
|
|
|
|
ogs_error(
|
|
|
|
|
"Overflow TAI range: "
|
|
|
|
|
"LOW:%s,HIGH:%s",
|
|
|
|
|
low, high);
|
|
|
|
|
else
|
|
|
|
|
num_of_tac++;
|
|
|
|
|
} else {
|
|
|
|
|
end[num_of_tac] =
|
|
|
|
|
start[num_of_tac];
|
|
|
|
|
num_of_tac++;
|
|
|
|
|
}
|
|
|
|
|
}
|
2017-12-10 15:01:02 +00:00
|
|
|
}
|
2019-05-29 12:27:22 +00:00
|
|
|
} while (
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_type(&tac_iter) ==
|
2017-12-10 15:01:02 +00:00
|
|
|
YAML_SEQUENCE_NODE);
|
2019-05-29 12:27:22 +00:00
|
|
|
} else
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_warn("unknown key `%s`", tai_key);
|
2017-07-14 10:00:26 +00:00
|
|
|
}
|
2017-11-29 00:41:29 +00:00
|
|
|
|
2019-05-18 15:24:15 +00:00
|
|
|
if (mcc && mnc && num_of_tac) {
|
2023-03-19 09:25:59 +00:00
|
|
|
if (num_of_tac == 1 && start[0] == end[0]) {
|
|
|
|
|
ogs_assert(list2->num < OGS_MAX_NUM_OF_TAI);
|
|
|
|
|
|
|
|
|
|
list2->type = OGS_TAI2_TYPE;
|
|
|
|
|
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_plmn_id_build(
|
2017-12-10 15:01:02 +00:00
|
|
|
&list2->tai[list2->num].plmn_id,
|
|
|
|
|
atoi(mcc), atoi(mnc), strlen(mnc));
|
2023-03-19 09:25:59 +00:00
|
|
|
list2->tai[list2->num].tac = start[0];
|
2017-12-10 15:01:02 +00:00
|
|
|
|
|
|
|
|
list2->num++;
|
|
|
|
|
|
2023-03-19 09:25:59 +00:00
|
|
|
} else {
|
|
|
|
|
int tac, count = 0;
|
|
|
|
|
for (tac = 0; tac < num_of_tac; tac++) {
|
|
|
|
|
ogs_assert(end[tac] >= start[tac]);
|
|
|
|
|
if (start[tac] == end[tac]) {
|
|
|
|
|
ogs_assert(num_of_list0 <
|
|
|
|
|
OGS_MAX_NUM_OF_TAI);
|
|
|
|
|
|
|
|
|
|
list0->tai[num_of_list0].type =
|
|
|
|
|
OGS_TAI0_TYPE;
|
2017-12-10 15:01:02 +00:00
|
|
|
|
2023-03-19 09:25:59 +00:00
|
|
|
ogs_plmn_id_build(
|
|
|
|
|
&list0->tai[num_of_list0].plmn_id,
|
|
|
|
|
atoi(mcc), atoi(mnc), strlen(mnc));
|
|
|
|
|
list0->tai[num_of_list0].
|
|
|
|
|
tac[count] = start[tac];
|
|
|
|
|
|
|
|
|
|
list0->tai[num_of_list0].num =
|
|
|
|
|
++count;
|
|
|
|
|
|
|
|
|
|
} else if (start[tac] < end[tac]) {
|
|
|
|
|
ogs_assert(num_of_list1 <
|
|
|
|
|
OGS_MAX_NUM_OF_TAI);
|
|
|
|
|
|
|
|
|
|
list1->tai[num_of_list1].type =
|
|
|
|
|
OGS_TAI1_TYPE;
|
|
|
|
|
|
|
|
|
|
ogs_plmn_id_build(
|
|
|
|
|
&list1->tai[num_of_list1].plmn_id,
|
|
|
|
|
atoi(mcc), atoi(mnc), strlen(mnc));
|
|
|
|
|
list1->tai[num_of_list1].tac =
|
|
|
|
|
start[tac];
|
|
|
|
|
|
|
|
|
|
list1->tai[num_of_list1].num =
|
|
|
|
|
end[tac]-start[tac]+1;
|
|
|
|
|
|
|
|
|
|
num_of_list1++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (count)
|
|
|
|
|
num_of_list0++;
|
2017-12-10 15:01:02 +00:00
|
|
|
}
|
2019-05-29 12:27:22 +00:00
|
|
|
} else {
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_warn("Ignore tai : mcc(%p), mnc(%p), "
|
2017-12-10 15:01:02 +00:00
|
|
|
"num_of_tac(%d)", mcc, mnc, num_of_tac);
|
2017-11-29 00:41:29 +00:00
|
|
|
}
|
2019-05-29 12:27:22 +00:00
|
|
|
} while (ogs_yaml_iter_type(&tai_array) ==
|
2017-11-29 00:41:29 +00:00
|
|
|
YAML_SEQUENCE_NODE);
|
2017-12-10 15:01:02 +00:00
|
|
|
|
2023-03-19 09:25:59 +00:00
|
|
|
if (list2->num || num_of_list1 || num_of_list0) {
|
2017-12-10 15:01:02 +00:00
|
|
|
self.num_of_served_tai++;
|
|
|
|
|
}
|
2023-03-25 00:18:20 +00:00
|
|
|
} else if (!strcmp(mme_key, "access_control")) {
|
|
|
|
|
ogs_yaml_iter_t access_control_array, access_control_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&mme_iter, &access_control_array);
|
|
|
|
|
do {
|
|
|
|
|
if (ogs_yaml_iter_type(&access_control_array) ==
|
|
|
|
|
YAML_MAPPING_NODE) {
|
|
|
|
|
memcpy(&access_control_iter, &access_control_array,
|
|
|
|
|
sizeof(ogs_yaml_iter_t));
|
|
|
|
|
} else if (ogs_yaml_iter_type(&access_control_array) ==
|
|
|
|
|
YAML_SEQUENCE_NODE) {
|
|
|
|
|
if (!ogs_yaml_iter_next(&access_control_array))
|
|
|
|
|
break;
|
|
|
|
|
ogs_yaml_iter_recurse(&access_control_array,
|
|
|
|
|
&access_control_iter);
|
|
|
|
|
} else if (ogs_yaml_iter_type(&access_control_array) ==
|
|
|
|
|
YAML_SCALAR_NODE) {
|
|
|
|
|
break;
|
|
|
|
|
} else
|
|
|
|
|
ogs_assert_if_reached();
|
|
|
|
|
|
2023-12-03 14:52:29 +00:00
|
|
|
ogs_assert(self.num_of_access_control <
|
|
|
|
|
OGS_MAX_NUM_OF_PLMN_PER_MME);
|
|
|
|
|
|
2023-03-25 00:18:20 +00:00
|
|
|
while (ogs_yaml_iter_next(&access_control_iter)) {
|
|
|
|
|
const char *mnc = NULL, *mcc = NULL;
|
|
|
|
|
int reject_cause = 0;
|
|
|
|
|
const char *access_control_key =
|
|
|
|
|
ogs_yaml_iter_key(&access_control_iter);
|
|
|
|
|
ogs_assert(access_control_key);
|
|
|
|
|
if (!strcmp(access_control_key,
|
|
|
|
|
"default_reject_cause")) {
|
|
|
|
|
const char *v = ogs_yaml_iter_value(
|
|
|
|
|
&access_control_iter);
|
|
|
|
|
if (v) self.default_reject_cause = atoi(v);
|
|
|
|
|
} else if (!strcmp(access_control_key, "plmn_id")) {
|
|
|
|
|
ogs_yaml_iter_t plmn_id_iter;
|
|
|
|
|
|
|
|
|
|
ogs_yaml_iter_recurse(&access_control_iter,
|
|
|
|
|
&plmn_id_iter);
|
|
|
|
|
while (ogs_yaml_iter_next(&plmn_id_iter)) {
|
|
|
|
|
const char *plmn_id_key =
|
|
|
|
|
ogs_yaml_iter_key(&plmn_id_iter);
|
|
|
|
|
ogs_assert(plmn_id_key);
|
|
|
|
|
if (!strcmp(plmn_id_key, "reject_cause")) {
|
|
|
|
|
const char *v = ogs_yaml_iter_value(
|
|
|
|
|
&plmn_id_iter);
|
|
|
|
|
if (v) reject_cause = atoi(v);
|
|
|
|
|
} else if (!strcmp(plmn_id_key, "mcc")) {
|
|
|
|
|
mcc = ogs_yaml_iter_value(
|
|
|
|
|
&plmn_id_iter);
|
|
|
|
|
} else if (!strcmp(plmn_id_key, "mnc")) {
|
|
|
|
|
mnc = ogs_yaml_iter_value(
|
|
|
|
|
&plmn_id_iter);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (mcc && mnc) {
|
|
|
|
|
ogs_plmn_id_build(
|
|
|
|
|
&self.access_control[
|
|
|
|
|
self.num_of_access_control].
|
|
|
|
|
plmn_id,
|
|
|
|
|
atoi(mcc), atoi(mnc), strlen(mnc));
|
|
|
|
|
if (reject_cause)
|
|
|
|
|
self.access_control[
|
|
|
|
|
self.num_of_access_control].
|
|
|
|
|
reject_cause = reject_cause;
|
|
|
|
|
self.num_of_access_control++;
|
|
|
|
|
}
|
|
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown key `%s`",
|
|
|
|
|
access_control_key);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} while (ogs_yaml_iter_type(&access_control_array) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (!strcmp(mme_key, "security")) {
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_t security_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&mme_iter, &security_iter);
|
2019-05-29 12:27:22 +00:00
|
|
|
while (ogs_yaml_iter_next(&security_iter)) {
|
2017-11-08 15:05:18 +00:00
|
|
|
const char *security_key =
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_key(&security_iter);
|
|
|
|
|
ogs_assert(security_key);
|
2019-05-18 15:24:15 +00:00
|
|
|
if (!strcmp(security_key, "integrity_order")) {
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_t integrity_order_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&security_iter,
|
2017-11-29 00:41:29 +00:00
|
|
|
&integrity_order_iter);
|
2020-04-27 02:18:47 +00:00
|
|
|
ogs_assert(ogs_yaml_iter_type(
|
|
|
|
|
&integrity_order_iter) !=
|
2019-04-27 14:54:30 +00:00
|
|
|
YAML_MAPPING_NODE);
|
2017-07-14 10:00:26 +00:00
|
|
|
|
2019-05-18 15:24:15 +00:00
|
|
|
do {
|
2017-11-29 00:41:29 +00:00
|
|
|
const char *v = NULL;
|
2017-07-14 10:00:26 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
if (ogs_yaml_iter_type(&integrity_order_iter) ==
|
2019-05-18 15:24:15 +00:00
|
|
|
YAML_SEQUENCE_NODE) {
|
2020-04-27 02:18:47 +00:00
|
|
|
if (!ogs_yaml_iter_next(
|
|
|
|
|
&integrity_order_iter))
|
2017-11-29 00:41:29 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
v = ogs_yaml_iter_value(&integrity_order_iter);
|
2019-05-18 15:24:15 +00:00
|
|
|
if (v) {
|
2022-03-01 08:13:40 +00:00
|
|
|
int integrity_index =
|
2017-11-29 00:41:29 +00:00
|
|
|
self.num_of_integrity_order;
|
2019-05-18 15:24:15 +00:00
|
|
|
if (strcmp(v, "EIA0") == 0) {
|
2022-03-01 08:13:40 +00:00
|
|
|
self.integrity_order[integrity_index] =
|
2020-04-27 02:18:47 +00:00
|
|
|
OGS_NAS_SECURITY_ALGORITHMS_EIA0;
|
2017-07-14 11:46:15 +00:00
|
|
|
self.num_of_integrity_order++;
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (strcmp(v, "EIA1") == 0) {
|
2022-03-01 08:13:40 +00:00
|
|
|
self.integrity_order[integrity_index] =
|
2020-04-27 02:18:47 +00:00
|
|
|
OGS_NAS_SECURITY_ALGORITHMS_128_EIA1;
|
2017-07-14 11:46:15 +00:00
|
|
|
self.num_of_integrity_order++;
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (strcmp(v, "EIA2") == 0) {
|
2022-03-01 08:13:40 +00:00
|
|
|
self.integrity_order[integrity_index] =
|
2020-04-27 02:18:47 +00:00
|
|
|
OGS_NAS_SECURITY_ALGORITHMS_128_EIA2;
|
2017-07-14 11:46:15 +00:00
|
|
|
self.num_of_integrity_order++;
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (strcmp(v, "EIA3") == 0) {
|
2022-03-01 08:13:40 +00:00
|
|
|
self.integrity_order[integrity_index] =
|
2020-04-27 02:18:47 +00:00
|
|
|
OGS_NAS_SECURITY_ALGORITHMS_128_EIA3;
|
2017-07-14 11:46:15 +00:00
|
|
|
self.num_of_integrity_order++;
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-05-29 12:27:22 +00:00
|
|
|
} while (
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_type(&integrity_order_iter) ==
|
2017-11-29 00:41:29 +00:00
|
|
|
YAML_SEQUENCE_NODE);
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (!strcmp(security_key, "ciphering_order")) {
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_t ciphering_order_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&security_iter,
|
2017-11-29 00:41:29 +00:00
|
|
|
&ciphering_order_iter);
|
2020-04-27 02:18:47 +00:00
|
|
|
ogs_assert(ogs_yaml_iter_type(
|
|
|
|
|
&ciphering_order_iter) != YAML_MAPPING_NODE);
|
2017-07-14 10:00:26 +00:00
|
|
|
|
2019-05-18 15:24:15 +00:00
|
|
|
do {
|
2017-11-29 00:41:29 +00:00
|
|
|
const char *v = NULL;
|
2017-07-14 10:00:26 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
if (ogs_yaml_iter_type(&ciphering_order_iter) ==
|
2019-05-18 15:24:15 +00:00
|
|
|
YAML_SEQUENCE_NODE) {
|
2020-04-27 02:18:47 +00:00
|
|
|
if (!ogs_yaml_iter_next(
|
|
|
|
|
&ciphering_order_iter))
|
2017-11-29 00:41:29 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
v = ogs_yaml_iter_value(&ciphering_order_iter);
|
2019-05-18 15:24:15 +00:00
|
|
|
if (v) {
|
2022-03-01 08:13:40 +00:00
|
|
|
int ciphering_index =
|
2017-11-29 00:41:29 +00:00
|
|
|
self.num_of_ciphering_order;
|
2019-05-18 15:24:15 +00:00
|
|
|
if (strcmp(v, "EEA0") == 0) {
|
2022-03-01 08:13:40 +00:00
|
|
|
self.ciphering_order[ciphering_index] =
|
2019-09-13 12:07:47 +00:00
|
|
|
OGS_NAS_SECURITY_ALGORITHMS_EEA0;
|
2017-07-14 11:46:15 +00:00
|
|
|
self.num_of_ciphering_order++;
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (strcmp(v, "EEA1") == 0) {
|
2022-03-01 08:13:40 +00:00
|
|
|
self.ciphering_order[ciphering_index] =
|
2020-04-27 02:18:47 +00:00
|
|
|
OGS_NAS_SECURITY_ALGORITHMS_128_EEA1;
|
2017-07-14 11:46:15 +00:00
|
|
|
self.num_of_ciphering_order++;
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (strcmp(v, "EEA2") == 0) {
|
2022-03-01 08:13:40 +00:00
|
|
|
self.ciphering_order[ciphering_index] =
|
2020-04-27 02:18:47 +00:00
|
|
|
OGS_NAS_SECURITY_ALGORITHMS_128_EEA2;
|
2017-07-14 11:46:15 +00:00
|
|
|
self.num_of_ciphering_order++;
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (strcmp(v, "EEA3") == 0) {
|
2022-03-01 08:13:40 +00:00
|
|
|
self.ciphering_order[ciphering_index] =
|
2020-04-27 02:18:47 +00:00
|
|
|
OGS_NAS_SECURITY_ALGORITHMS_128_EEA3;
|
2017-07-14 11:46:15 +00:00
|
|
|
self.num_of_ciphering_order++;
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-05-29 12:27:22 +00:00
|
|
|
} while (
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_type(&ciphering_order_iter) ==
|
2017-11-29 00:41:29 +00:00
|
|
|
YAML_SEQUENCE_NODE);
|
2023-03-25 00:18:20 +00:00
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown key `%s`", security_key);
|
2017-07-14 10:00:26 +00:00
|
|
|
}
|
2019-06-02 12:55:24 +00:00
|
|
|
} else if (!strcmp(mme_key, "network_name")) {
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_t network_name_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&mme_iter, &network_name_iter);
|
2018-02-25 21:33:36 +00:00
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
while (ogs_yaml_iter_next(&network_name_iter)) {
|
2018-02-25 21:33:36 +00:00
|
|
|
const char *network_name_key =
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_key(&network_name_iter);
|
|
|
|
|
ogs_assert(network_name_key);
|
2022-03-01 08:13:40 +00:00
|
|
|
if (!strcmp(network_name_key, "full")) {
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_nas_network_name_t *network_full_name =
|
2018-02-27 02:59:08 +00:00
|
|
|
&self.full_name;
|
|
|
|
|
const char *c_network_name =
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_value(&network_name_iter);
|
|
|
|
|
uint8_t size = strlen(c_network_name);
|
|
|
|
|
uint8_t i;
|
2019-05-18 15:24:15 +00:00
|
|
|
for (i = 0;i<size;i++) {
|
2018-02-25 21:33:36 +00:00
|
|
|
/* Workaround to convert the ASCII to USC-2 */
|
|
|
|
|
network_full_name->name[i*2] = 0;
|
2018-02-27 02:59:08 +00:00
|
|
|
network_full_name->name[(i*2)+1] =
|
|
|
|
|
c_network_name[i];
|
2018-02-25 21:33:36 +00:00
|
|
|
|
|
|
|
|
}
|
2019-05-18 15:24:15 +00:00
|
|
|
network_full_name->length = size*2+1;
|
|
|
|
|
network_full_name->coding_scheme = 1;
|
2022-06-19 09:16:11 +00:00
|
|
|
network_full_name->ext = 1;
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (!strcmp(network_name_key, "short")) {
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_nas_network_name_t *network_short_name =
|
2018-02-27 02:59:08 +00:00
|
|
|
&self.short_name;
|
|
|
|
|
const char *c_network_name =
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_yaml_iter_value(&network_name_iter);
|
|
|
|
|
uint8_t size = strlen(c_network_name);
|
|
|
|
|
uint8_t i;
|
2019-05-18 15:24:15 +00:00
|
|
|
for (i = 0;i<size;i++) {
|
2018-02-25 21:33:36 +00:00
|
|
|
/* Workaround to convert the ASCII to USC-2 */
|
|
|
|
|
network_short_name->name[i*2] = 0;
|
2018-02-27 02:59:08 +00:00
|
|
|
network_short_name->name[(i*2)+1] =
|
|
|
|
|
c_network_name[i];
|
2018-02-25 21:33:36 +00:00
|
|
|
|
|
|
|
|
}
|
|
|
|
|
network_short_name->length = size*2+1;
|
|
|
|
|
network_short_name->coding_scheme = 1;
|
2022-06-19 09:16:11 +00:00
|
|
|
network_short_name->ext = 1;
|
2023-03-25 00:18:20 +00:00
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown key `%s`", network_name_key);
|
2018-02-25 21:33:36 +00:00
|
|
|
}
|
2019-06-02 12:55:24 +00:00
|
|
|
} else if (!strcmp(mme_key, "sgsap")) {
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_yaml_iter_t sgsap_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&mme_iter, &sgsap_iter);
|
|
|
|
|
while (ogs_yaml_iter_next(&sgsap_iter)) {
|
|
|
|
|
const char *sgsap_key = ogs_yaml_iter_key(&sgsap_iter);
|
|
|
|
|
ogs_assert(sgsap_key);
|
|
|
|
|
if (!strcmp(sgsap_key, "server")) {
|
|
|
|
|
ogs_yaml_iter_t server_iter, server_array;
|
|
|
|
|
ogs_yaml_iter_recurse(&sgsap_iter, &server_array);
|
|
|
|
|
do {
|
|
|
|
|
mme_vlr_t *vlr = NULL;
|
|
|
|
|
ogs_plmn_id_t plmn_id;
|
2019-07-21 11:06:08 +00:00
|
|
|
#define MAX_NUM_OF_CSMAP 128 /* Num of TAI-LAI MAP per MME */
|
2023-11-19 10:34:51 +00:00
|
|
|
struct {
|
|
|
|
|
const char *tai_mcc, *tai_mnc;
|
|
|
|
|
const char *lai_mcc, *lai_mnc;
|
|
|
|
|
const char *tac, *lac;
|
|
|
|
|
} map[MAX_NUM_OF_CSMAP];
|
|
|
|
|
int map_num = 0;
|
|
|
|
|
ogs_sockaddr_t *addr = NULL;
|
|
|
|
|
int family = AF_UNSPEC;
|
|
|
|
|
int i, hostname_num = 0;
|
|
|
|
|
const char *hostname[OGS_MAX_NUM_OF_HOSTNAME];
|
|
|
|
|
uint16_t port = self.sgsap_port;
|
|
|
|
|
|
|
|
|
|
ogs_sockopt_t option;
|
|
|
|
|
bool is_option = false;
|
|
|
|
|
|
|
|
|
|
if (ogs_yaml_iter_type(&server_array) ==
|
|
|
|
|
YAML_MAPPING_NODE) {
|
|
|
|
|
memcpy(&server_iter, &server_array,
|
|
|
|
|
sizeof(ogs_yaml_iter_t));
|
|
|
|
|
} else if (ogs_yaml_iter_type(&server_array) ==
|
|
|
|
|
YAML_SEQUENCE_NODE) {
|
|
|
|
|
if (!ogs_yaml_iter_next(&server_array))
|
|
|
|
|
break;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&server_array, &server_iter);
|
|
|
|
|
} else if (ogs_yaml_iter_type(&server_array) ==
|
|
|
|
|
YAML_SCALAR_NODE) {
|
|
|
|
|
break;
|
|
|
|
|
} else
|
|
|
|
|
ogs_assert_if_reached();
|
|
|
|
|
|
|
|
|
|
while (ogs_yaml_iter_next(&server_iter)) {
|
|
|
|
|
const char *server_key =
|
|
|
|
|
ogs_yaml_iter_key(&server_iter);
|
|
|
|
|
ogs_assert(server_key);
|
|
|
|
|
if (!strcmp(server_key, "family")) {
|
|
|
|
|
const char *v =
|
|
|
|
|
ogs_yaml_iter_value(&server_iter);
|
|
|
|
|
if (v) family = atoi(v);
|
|
|
|
|
if (family != AF_UNSPEC &&
|
|
|
|
|
family != AF_INET &&
|
|
|
|
|
family != AF_INET6) {
|
|
|
|
|
ogs_warn("Ignore family(%d) : "
|
|
|
|
|
"AF_UNSPEC(%d), "
|
|
|
|
|
"AF_INET(%d), AF_INET6(%d) ",
|
|
|
|
|
family,
|
|
|
|
|
AF_UNSPEC, AF_INET, AF_INET6);
|
|
|
|
|
family = AF_UNSPEC;
|
|
|
|
|
}
|
|
|
|
|
} else if (!strcmp(server_key, "address")) {
|
|
|
|
|
ogs_yaml_iter_t hostname_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&server_iter,
|
|
|
|
|
&hostname_iter);
|
|
|
|
|
ogs_assert(ogs_yaml_iter_type(
|
|
|
|
|
&hostname_iter) !=
|
|
|
|
|
YAML_MAPPING_NODE);
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
if (ogs_yaml_iter_type(
|
|
|
|
|
&hostname_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE) {
|
|
|
|
|
if (!ogs_yaml_iter_next(
|
|
|
|
|
&hostname_iter))
|
|
|
|
|
break;
|
|
|
|
|
}
|
2019-06-02 12:55:24 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_assert(hostname_num <
|
|
|
|
|
OGS_MAX_NUM_OF_HOSTNAME);
|
|
|
|
|
hostname[hostname_num++] =
|
|
|
|
|
ogs_yaml_iter_value(
|
|
|
|
|
&hostname_iter);
|
|
|
|
|
} while (ogs_yaml_iter_type(
|
|
|
|
|
&hostname_iter) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
|
|
|
|
} else if (!strcmp(server_key, "port")) {
|
|
|
|
|
const char *v =
|
|
|
|
|
ogs_yaml_iter_value(&server_iter);
|
|
|
|
|
if (v) {
|
|
|
|
|
port = atoi(v);
|
|
|
|
|
self.sgsap_port = port;
|
|
|
|
|
}
|
|
|
|
|
} else if (!strcmp(server_key, "option")) {
|
|
|
|
|
rv = ogs_app_parse_sockopt_config(
|
|
|
|
|
&server_iter, &option);
|
|
|
|
|
if (rv != OGS_OK) {
|
|
|
|
|
ogs_error("ogs_app_parse_sockopt_"
|
|
|
|
|
"config() failed");
|
|
|
|
|
return rv;
|
|
|
|
|
}
|
|
|
|
|
is_option = true;
|
|
|
|
|
} else if (!strcmp(server_key, "map")) {
|
|
|
|
|
ogs_yaml_iter_t map_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&server_iter, &map_iter);
|
|
|
|
|
|
|
|
|
|
map[map_num].tai_mcc = NULL;
|
|
|
|
|
map[map_num].tai_mnc = NULL;
|
|
|
|
|
map[map_num].tac = NULL;
|
|
|
|
|
map[map_num].lai_mcc = NULL;
|
|
|
|
|
map[map_num].lai_mnc = NULL;
|
|
|
|
|
map[map_num].lac = NULL;
|
|
|
|
|
|
|
|
|
|
while (ogs_yaml_iter_next(&map_iter)) {
|
|
|
|
|
const char *map_key =
|
|
|
|
|
ogs_yaml_iter_key(&map_iter);
|
|
|
|
|
ogs_assert(map_key);
|
|
|
|
|
if (!strcmp(map_key, "tai")) {
|
|
|
|
|
ogs_yaml_iter_t tai_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&map_iter,
|
|
|
|
|
&tai_iter);
|
2019-07-21 11:06:08 +00:00
|
|
|
|
|
|
|
|
while (ogs_yaml_iter_next(
|
2023-11-19 10:34:51 +00:00
|
|
|
&tai_iter)) {
|
|
|
|
|
const char *tai_key =
|
|
|
|
|
ogs_yaml_iter_key(
|
|
|
|
|
&tai_iter);
|
|
|
|
|
ogs_assert(tai_key);
|
|
|
|
|
|
|
|
|
|
if (!strcmp(tai_key,
|
|
|
|
|
"plmn_id")) {
|
|
|
|
|
ogs_yaml_iter_t
|
|
|
|
|
plmn_id_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&tai_iter,
|
|
|
|
|
&plmn_id_iter);
|
|
|
|
|
|
|
|
|
|
while (
|
|
|
|
|
ogs_yaml_iter_next(
|
2019-07-21 11:06:08 +00:00
|
|
|
&plmn_id_iter)) {
|
2023-11-19 10:34:51 +00:00
|
|
|
const char
|
|
|
|
|
*plmn_id_key =
|
|
|
|
|
ogs_yaml_iter_key(
|
|
|
|
|
&plmn_id_iter);
|
|
|
|
|
ogs_assert(
|
|
|
|
|
plmn_id_key);
|
2019-07-21 11:06:08 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
if (!strcmp(
|
|
|
|
|
plmn_id_key,
|
|
|
|
|
"mcc")) {
|
|
|
|
|
map[map_num].
|
|
|
|
|
tai_mcc =
|
2019-07-21 11:06:08 +00:00
|
|
|
ogs_yaml_iter_value(
|
|
|
|
|
&plmn_id_iter);
|
2023-11-19 10:34:51 +00:00
|
|
|
} else if (!strcmp(
|
|
|
|
|
plmn_id_key,
|
|
|
|
|
"mnc")) {
|
|
|
|
|
map[map_num].
|
|
|
|
|
tai_mnc =
|
2019-07-21 11:06:08 +00:00
|
|
|
ogs_yaml_iter_value(
|
|
|
|
|
&plmn_id_iter);
|
2023-11-19 10:34:51 +00:00
|
|
|
} else
|
|
|
|
|
ogs_warn(
|
|
|
|
|
"unknown key `%s`",
|
|
|
|
|
plmn_id_key);
|
|
|
|
|
}
|
|
|
|
|
} else if (!strcmp(tai_key,
|
|
|
|
|
"tac")) {
|
|
|
|
|
map[map_num].tac =
|
|
|
|
|
ogs_yaml_iter_value(
|
|
|
|
|
&tai_iter);
|
2019-07-21 11:06:08 +00:00
|
|
|
} else
|
|
|
|
|
ogs_warn(
|
|
|
|
|
"unknown key `%s`",
|
2023-11-19 10:34:51 +00:00
|
|
|
tai_key);
|
2019-07-21 11:06:08 +00:00
|
|
|
}
|
2023-11-19 10:34:51 +00:00
|
|
|
} else if (!strcmp(map_key,
|
|
|
|
|
"lai")) {
|
|
|
|
|
ogs_yaml_iter_t lai_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&map_iter,
|
|
|
|
|
&lai_iter);
|
2019-07-21 11:06:08 +00:00
|
|
|
|
|
|
|
|
while (ogs_yaml_iter_next(
|
2023-11-19 10:34:51 +00:00
|
|
|
&lai_iter)) {
|
|
|
|
|
const char *lai_key =
|
|
|
|
|
ogs_yaml_iter_key(
|
|
|
|
|
&lai_iter);
|
|
|
|
|
ogs_assert(lai_key);
|
|
|
|
|
|
|
|
|
|
if (!strcmp(lai_key,
|
|
|
|
|
"plmn_id")) {
|
|
|
|
|
ogs_yaml_iter_t
|
|
|
|
|
plmn_id_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(
|
|
|
|
|
&lai_iter,
|
|
|
|
|
&plmn_id_iter);
|
|
|
|
|
|
|
|
|
|
while (
|
|
|
|
|
ogs_yaml_iter_next(
|
2019-07-21 11:06:08 +00:00
|
|
|
&plmn_id_iter)) {
|
2023-11-19 10:34:51 +00:00
|
|
|
const char
|
|
|
|
|
*plmn_id_key =
|
|
|
|
|
ogs_yaml_iter_key(
|
|
|
|
|
&plmn_id_iter);
|
|
|
|
|
ogs_assert(
|
|
|
|
|
plmn_id_key);
|
2019-07-21 11:06:08 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
if (!strcmp(
|
|
|
|
|
plmn_id_key,
|
2019-07-21 11:06:08 +00:00
|
|
|
"mcc")) {
|
2023-11-19 10:34:51 +00:00
|
|
|
map[map_num].
|
|
|
|
|
lai_mcc =
|
2019-07-21 11:06:08 +00:00
|
|
|
ogs_yaml_iter_value(
|
|
|
|
|
&plmn_id_iter);
|
2023-11-19 10:34:51 +00:00
|
|
|
} else if (!strcmp(
|
|
|
|
|
plmn_id_key,
|
|
|
|
|
"mnc")) {
|
|
|
|
|
map[map_num].
|
|
|
|
|
lai_mnc =
|
2019-07-21 11:06:08 +00:00
|
|
|
ogs_yaml_iter_value(
|
|
|
|
|
&plmn_id_iter);
|
2023-11-19 10:34:51 +00:00
|
|
|
} else
|
|
|
|
|
ogs_warn(
|
|
|
|
|
"unknown key `%s`",
|
|
|
|
|
plmn_id_key);
|
|
|
|
|
}
|
|
|
|
|
} else if (!strcmp(lai_key,
|
|
|
|
|
"lac")) {
|
|
|
|
|
map[map_num].lac =
|
|
|
|
|
ogs_yaml_iter_value(
|
|
|
|
|
&lai_iter);
|
2019-07-21 11:06:08 +00:00
|
|
|
} else
|
|
|
|
|
ogs_warn(
|
|
|
|
|
"unknown key `%s`",
|
2023-11-19 10:34:51 +00:00
|
|
|
lai_key);
|
2019-07-21 11:06:08 +00:00
|
|
|
}
|
2019-07-14 04:48:14 +00:00
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown key `%s`",
|
2023-11-19 10:34:51 +00:00
|
|
|
map_key);
|
2019-07-14 04:48:14 +00:00
|
|
|
}
|
2019-06-02 12:55:24 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
if (!map[map_num].tai_mcc) {
|
|
|
|
|
ogs_error("No map.tai.plmn_id.mcc "
|
|
|
|
|
"in configuration file");
|
|
|
|
|
return OGS_ERROR;
|
2023-07-06 16:03:42 +00:00
|
|
|
}
|
2023-11-19 10:34:51 +00:00
|
|
|
if (!map[map_num].tai_mnc) {
|
|
|
|
|
ogs_error("No map.tai.plmn_id.mnc "
|
|
|
|
|
"in configuration file");
|
|
|
|
|
return OGS_ERROR;
|
2023-07-06 16:03:42 +00:00
|
|
|
}
|
2023-11-19 10:34:51 +00:00
|
|
|
if (!map[map_num].tac) {
|
|
|
|
|
ogs_error("No map.tai.tac "
|
|
|
|
|
"in configuration file");
|
|
|
|
|
return OGS_ERROR;
|
|
|
|
|
}
|
|
|
|
|
if (!map[map_num].lai_mcc) {
|
|
|
|
|
ogs_error("No map.lai.plmn_id.mcc "
|
|
|
|
|
"in configuration file");
|
|
|
|
|
return OGS_ERROR;
|
|
|
|
|
}
|
|
|
|
|
if (!map[map_num].lai_mnc) {
|
|
|
|
|
ogs_error("No map.lai.plmn_id.mnc "
|
|
|
|
|
"in configuration file");
|
|
|
|
|
return OGS_ERROR;
|
|
|
|
|
}
|
|
|
|
|
if (!map[map_num].lac) {
|
|
|
|
|
ogs_error("No map.lai.lac "
|
|
|
|
|
"in configuration file");
|
|
|
|
|
return OGS_ERROR;
|
2023-07-06 16:03:42 +00:00
|
|
|
}
|
2017-11-08 15:05:18 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
map_num++;
|
|
|
|
|
|
|
|
|
|
} else if (!strcmp(server_key, "tai")) {
|
|
|
|
|
ogs_error(
|
|
|
|
|
"tai/lai configuraton changed to "
|
|
|
|
|
"map.tai/map.lai");
|
|
|
|
|
ogs_log_print(OGS_LOG_ERROR,
|
|
|
|
|
"sgsap:\n"
|
|
|
|
|
" server\n"
|
|
|
|
|
" address: 127.0.0.2\n"
|
|
|
|
|
" map:\n"
|
|
|
|
|
" tai:\n"
|
|
|
|
|
" plmn_id:\n"
|
|
|
|
|
" mcc: 001\n"
|
|
|
|
|
" mnc: 01\n"
|
|
|
|
|
" tac: 4131\n"
|
|
|
|
|
" lai:\n"
|
|
|
|
|
" plmn_id:\n"
|
|
|
|
|
" mcc: 001\n"
|
|
|
|
|
" mnc: 01\n"
|
|
|
|
|
" lac: 43691\n");
|
|
|
|
|
return OGS_ERROR;
|
|
|
|
|
} else if (!strcmp(server_key, "lai")) {
|
|
|
|
|
ogs_error(
|
|
|
|
|
"tai/lai configuraton changed to "
|
|
|
|
|
"map.tai/map.lai");
|
|
|
|
|
ogs_log_print(OGS_LOG_ERROR,
|
|
|
|
|
"sgsap:\n"
|
|
|
|
|
" server\n"
|
|
|
|
|
" address: 127.0.0.2\n"
|
|
|
|
|
" map:\n"
|
|
|
|
|
" tai:\n"
|
|
|
|
|
" plmn_id:\n"
|
|
|
|
|
" mcc: 001\n"
|
|
|
|
|
" mnc: 01\n"
|
|
|
|
|
" tac: 4131\n"
|
|
|
|
|
" lai:\n"
|
|
|
|
|
" plmn_id:\n"
|
|
|
|
|
" mcc: 001\n"
|
|
|
|
|
" mnc: 01\n"
|
|
|
|
|
" lac: 43691\n");
|
|
|
|
|
return OGS_ERROR;
|
|
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown key `%s`",
|
|
|
|
|
server_key);
|
2017-07-14 10:00:26 +00:00
|
|
|
|
2017-11-29 00:41:29 +00:00
|
|
|
}
|
2020-08-13 00:31:22 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
if (map_num == 0) {
|
|
|
|
|
ogs_error("No TAI-LAI Map");
|
|
|
|
|
return OGS_ERROR;
|
2017-11-29 00:41:29 +00:00
|
|
|
}
|
2019-06-05 12:21:19 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
addr = NULL;
|
|
|
|
|
for (i = 0; i < hostname_num; i++) {
|
|
|
|
|
rv = ogs_addaddrinfo(&addr,
|
|
|
|
|
family, hostname[i], port, 0);
|
|
|
|
|
ogs_assert(rv == OGS_OK);
|
|
|
|
|
}
|
2017-12-05 01:50:31 +00:00
|
|
|
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_filter_ip_version(&addr,
|
|
|
|
|
ogs_global_conf()->parameter.no_ipv4,
|
|
|
|
|
ogs_global_conf()->parameter.no_ipv6,
|
|
|
|
|
ogs_global_conf()->parameter.
|
|
|
|
|
prefer_ipv4);
|
|
|
|
|
|
|
|
|
|
if (addr == NULL) continue;
|
|
|
|
|
|
|
|
|
|
vlr = mme_vlr_add(addr,
|
|
|
|
|
is_option ? &option : NULL);
|
|
|
|
|
ogs_assert(vlr);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < map_num; i++) {
|
|
|
|
|
mme_csmap_t *csmap = mme_csmap_add(vlr);
|
|
|
|
|
ogs_assert(csmap);
|
|
|
|
|
|
|
|
|
|
ogs_plmn_id_build(&plmn_id,
|
|
|
|
|
atoi(map[i].tai_mcc),
|
|
|
|
|
atoi(map[i].tai_mnc),
|
|
|
|
|
strlen(map[i].tai_mnc));
|
|
|
|
|
ogs_nas_from_plmn_id(
|
|
|
|
|
&csmap->tai.nas_plmn_id, &plmn_id);
|
|
|
|
|
csmap->tai.tac = atoi(map[i].tac);
|
|
|
|
|
ogs_plmn_id_build(&plmn_id,
|
|
|
|
|
atoi(map[i].lai_mcc),
|
|
|
|
|
atoi(map[i].lai_mnc),
|
|
|
|
|
strlen(map[i].lai_mnc));
|
|
|
|
|
ogs_nas_from_plmn_id(
|
|
|
|
|
&csmap->lai.nas_plmn_id, &plmn_id);
|
|
|
|
|
csmap->lai.lac = atoi(map[i].lac);
|
|
|
|
|
}
|
|
|
|
|
} while (ogs_yaml_iter_type(&server_array) ==
|
|
|
|
|
YAML_SEQUENCE_NODE);
|
2022-11-29 14:22:16 +00:00
|
|
|
} else
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_warn("unknown key `%s`", sgsap_key);
|
2022-11-29 14:22:16 +00:00
|
|
|
}
|
2023-11-19 10:34:51 +00:00
|
|
|
} else if (!strcmp(mme_key, "mme_name")) {
|
|
|
|
|
self.mme_name = ogs_yaml_iter_value(&mme_iter);
|
|
|
|
|
} else if (!strcmp(mme_key, "time")) {
|
|
|
|
|
ogs_yaml_iter_t time_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&mme_iter, &time_iter);
|
|
|
|
|
while (ogs_yaml_iter_next(&time_iter)) {
|
|
|
|
|
const char *time_key = ogs_yaml_iter_key(&time_iter);
|
|
|
|
|
ogs_assert(time_key);
|
|
|
|
|
if (!strcmp(time_key, "t3402")) {
|
|
|
|
|
ogs_yaml_iter_t t3402_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&time_iter, &t3402_iter);
|
|
|
|
|
|
|
|
|
|
while (ogs_yaml_iter_next(&t3402_iter)) {
|
|
|
|
|
const char *t3402_key =
|
|
|
|
|
ogs_yaml_iter_key(&t3402_iter);
|
|
|
|
|
ogs_assert(t3402_key);
|
|
|
|
|
|
|
|
|
|
if (!strcmp(t3402_key, "value")) {
|
|
|
|
|
const char *v = ogs_yaml_iter_value(&t3402_iter);
|
|
|
|
|
if (v)
|
|
|
|
|
self.time.t3402.value = atoll(v);
|
|
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown key `%s`", t3402_key);
|
|
|
|
|
}
|
|
|
|
|
} else if (!strcmp(time_key, "t3412")) {
|
|
|
|
|
ogs_yaml_iter_t t3412_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&time_iter, &t3412_iter);
|
|
|
|
|
|
|
|
|
|
while (ogs_yaml_iter_next(&t3412_iter)) {
|
|
|
|
|
const char *t3412_key =
|
|
|
|
|
ogs_yaml_iter_key(&t3412_iter);
|
|
|
|
|
ogs_assert(t3412_key);
|
|
|
|
|
|
|
|
|
|
if (!strcmp(t3412_key, "value")) {
|
|
|
|
|
const char *v = ogs_yaml_iter_value(&t3412_iter);
|
|
|
|
|
if (v)
|
|
|
|
|
self.time.t3412.value = atoll(v);
|
|
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown key `%s`", t3412_key);
|
|
|
|
|
}
|
|
|
|
|
} else if (!strcmp(time_key, "t3423")) {
|
|
|
|
|
ogs_yaml_iter_t t3423_iter;
|
|
|
|
|
ogs_yaml_iter_recurse(&time_iter, &t3423_iter);
|
|
|
|
|
|
|
|
|
|
while (ogs_yaml_iter_next(&t3423_iter)) {
|
|
|
|
|
const char *t3423_key =
|
|
|
|
|
ogs_yaml_iter_key(&t3423_iter);
|
|
|
|
|
ogs_assert(t3423_key);
|
|
|
|
|
|
|
|
|
|
if (!strcmp(t3423_key, "value")) {
|
|
|
|
|
const char *v = ogs_yaml_iter_value(&t3423_iter);
|
|
|
|
|
if (v)
|
|
|
|
|
self.time.t3423.value = atoll(v);
|
|
|
|
|
} else
|
|
|
|
|
ogs_warn("unknown key `%s`", t3423_key);
|
|
|
|
|
}
|
|
|
|
|
} else if (!strcmp(time_key, "t3512")) {
|
|
|
|
|
/* handle config in amf */
|
|
|
|
|
} else if (!strcmp(time_key, "nf_instance")) {
|
|
|
|
|
/* handle config in app library */
|
|
|
|
|
} else if (!strcmp(time_key, "subscription")) {
|
|
|
|
|
/* handle config in app library */
|
|
|
|
|
} else if (!strcmp(time_key, "message")) {
|
|
|
|
|
/* handle config in app library */
|
|
|
|
|
} else if (!strcmp(time_key, "handover")) {
|
|
|
|
|
/* handle config in app library */
|
2022-11-29 14:22:16 +00:00
|
|
|
} else
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_warn("unknown key `%s`", time_key);
|
2022-11-29 14:22:16 +00:00
|
|
|
}
|
2023-11-19 10:34:51 +00:00
|
|
|
} else if (!strcmp(mme_key, "metrics")) {
|
|
|
|
|
/* handle config in metrics library */
|
2022-11-29 14:22:16 +00:00
|
|
|
} else
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_warn("unknown key `%s`", mme_key);
|
2022-11-29 14:22:16 +00:00
|
|
|
}
|
2017-11-27 11:23:16 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-07-14 11:04:11 +00:00
|
|
|
rv = mme_context_validation();
|
2019-04-27 14:54:30 +00:00
|
|
|
if (rv != OGS_OK) return rv;
|
2017-07-31 14:12:13 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_OK;
|
2017-07-31 13:35:25 +00:00
|
|
|
}
|
|
|
|
|
|
2023-07-06 16:03:42 +00:00
|
|
|
mme_sgsn_t *mme_sgsn_add(ogs_sockaddr_t *addr)
|
|
|
|
|
{
|
|
|
|
|
mme_sgsn_t *sgsn = NULL;
|
|
|
|
|
|
|
|
|
|
ogs_assert(addr);
|
|
|
|
|
|
|
|
|
|
ogs_pool_alloc(&mme_sgsn_pool, &sgsn);
|
|
|
|
|
ogs_assert(sgsn);
|
|
|
|
|
memset(sgsn, 0, sizeof *sgsn);
|
|
|
|
|
|
|
|
|
|
sgsn->gnode.sa_list = addr;
|
|
|
|
|
|
|
|
|
|
ogs_list_init(&sgsn->gnode.local_list);
|
|
|
|
|
ogs_list_init(&sgsn->gnode.remote_list);
|
|
|
|
|
|
|
|
|
|
ogs_list_init(&sgsn->route_list);
|
|
|
|
|
//ogs_list_init(&sgsn->sgsn_ue_list);
|
|
|
|
|
|
|
|
|
|
ogs_list_add(&self.sgsn_list, sgsn);
|
|
|
|
|
|
|
|
|
|
return sgsn;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void mme_sgsn_remove(mme_sgsn_t *sgsn)
|
|
|
|
|
{
|
|
|
|
|
mme_sgsn_route_t *rt = NULL, *next_rt = NULL;
|
|
|
|
|
ogs_assert(sgsn);
|
|
|
|
|
|
|
|
|
|
ogs_list_remove(&self.sgsn_list, sgsn);
|
|
|
|
|
|
|
|
|
|
ogs_gtp_xact_delete_all(&sgsn->gnode);
|
|
|
|
|
ogs_freeaddrinfo(sgsn->gnode.sa_list);
|
|
|
|
|
|
|
|
|
|
/* Free routes in list */
|
|
|
|
|
ogs_list_for_each_safe(&sgsn->route_list, next_rt, rt) {
|
|
|
|
|
ogs_list_remove(&sgsn->route_list, rt);
|
|
|
|
|
ogs_pool_free(&mme_sgsn_route_pool, rt);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ogs_pool_free(&mme_sgsn_pool, sgsn);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void mme_sgsn_remove_all(void)
|
|
|
|
|
{
|
|
|
|
|
mme_sgsn_t *sgsn = NULL, *next_sgsn = NULL;
|
|
|
|
|
|
|
|
|
|
ogs_list_for_each_safe(&self.sgsn_list, next_sgsn, sgsn)
|
|
|
|
|
mme_sgsn_remove(sgsn);
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
mme_sgsn_t *mme_sgsn_find_by_addr(const ogs_sockaddr_t *addr)
|
2023-07-06 16:03:42 +00:00
|
|
|
{
|
|
|
|
|
mme_sgsn_t *sgsn = NULL;
|
|
|
|
|
|
|
|
|
|
ogs_assert(addr);
|
|
|
|
|
|
|
|
|
|
ogs_list_for_each(&self.sgsn_list, sgsn) {
|
|
|
|
|
if (ogs_sockaddr_is_equal(&sgsn->gnode.addr, addr) == true)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return sgsn;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Find SGSN holding route provided in params. Return SGSN configured as default
|
|
|
|
|
* routing if no matching route found. */
|
|
|
|
|
mme_sgsn_t *mme_sgsn_find_by_routing_address(const ogs_nas_rai_t *rai, uint16_t cell_id)
|
|
|
|
|
{
|
|
|
|
|
mme_sgsn_t *sgsn = NULL;
|
|
|
|
|
ogs_list_for_each(&self.sgsn_list, sgsn) {
|
|
|
|
|
mme_sgsn_route_t *rt = NULL;
|
|
|
|
|
ogs_list_for_each(&sgsn->route_list, rt) {
|
|
|
|
|
if (rt->cell_id == cell_id &&
|
|
|
|
|
memcmp(&rt->rai, rai, sizeof(ogs_nas_rai_t)) == 0)
|
|
|
|
|
return sgsn;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-15 15:30:45 +00:00
|
|
|
/* If no exact match found, try using any with same RAI: */
|
|
|
|
|
ogs_list_for_each(&self.sgsn_list, sgsn) {
|
|
|
|
|
mme_sgsn_route_t *rt = NULL;
|
|
|
|
|
ogs_list_for_each(&sgsn->route_list, rt) {
|
|
|
|
|
if (memcmp(&rt->rai, rai, sizeof(ogs_nas_rai_t)) == 0)
|
|
|
|
|
return sgsn;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2023-07-06 16:03:42 +00:00
|
|
|
/* No route found, return default route if available: */
|
|
|
|
|
return mme_sgsn_find_by_default_routing_address();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return SGSN configured as default routing */
|
|
|
|
|
mme_sgsn_t *mme_sgsn_find_by_default_routing_address(void)
|
|
|
|
|
{
|
|
|
|
|
mme_sgsn_t *sgsn = NULL;
|
|
|
|
|
ogs_list_for_each(&self.sgsn_list, sgsn) {
|
|
|
|
|
if (sgsn->default_route)
|
|
|
|
|
return sgsn;
|
|
|
|
|
}
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-05 12:13:18 +00:00
|
|
|
mme_sgw_t *mme_sgw_add(ogs_sockaddr_t *addr)
|
2018-09-23 04:16:40 +00:00
|
|
|
{
|
|
|
|
|
mme_sgw_t *sgw = NULL;
|
|
|
|
|
|
2019-06-05 12:13:18 +00:00
|
|
|
ogs_assert(addr);
|
2018-09-23 04:16:40 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_pool_alloc(&mme_sgw_pool, &sgw);
|
|
|
|
|
ogs_assert(sgw);
|
2018-09-23 05:29:19 +00:00
|
|
|
memset(sgw, 0, sizeof *sgw);
|
2018-09-23 04:16:40 +00:00
|
|
|
|
2022-04-14 08:34:55 +00:00
|
|
|
sgw->gnode.sa_list = addr;
|
|
|
|
|
|
|
|
|
|
ogs_list_init(&sgw->gnode.local_list);
|
|
|
|
|
ogs_list_init(&sgw->gnode.remote_list);
|
2019-06-05 12:13:18 +00:00
|
|
|
|
2022-04-29 12:28:16 +00:00
|
|
|
ogs_list_init(&sgw->sgw_ue_list);
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_list_add(&self.sgw_list, sgw);
|
2018-09-23 04:16:40 +00:00
|
|
|
|
|
|
|
|
return sgw;
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-30 10:58:27 +00:00
|
|
|
void mme_sgw_remove(mme_sgw_t *sgw)
|
2018-09-23 04:16:40 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(sgw);
|
2018-09-23 04:16:40 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_list_remove(&self.sgw_list, sgw);
|
2018-09-23 04:16:40 +00:00
|
|
|
|
2022-04-14 08:34:55 +00:00
|
|
|
ogs_gtp_xact_delete_all(&sgw->gnode);
|
|
|
|
|
ogs_freeaddrinfo(sgw->gnode.sa_list);
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_pool_free(&mme_sgw_pool, sgw);
|
2018-09-23 04:16:40 +00:00
|
|
|
}
|
|
|
|
|
|
2023-04-04 12:53:39 +00:00
|
|
|
void mme_sgw_remove_all(void)
|
2018-09-23 04:16:40 +00:00
|
|
|
{
|
|
|
|
|
mme_sgw_t *sgw = NULL, *next_sgw = NULL;
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_list_for_each_safe(&self.sgw_list, next_sgw, sgw)
|
2018-09-23 04:16:40 +00:00
|
|
|
mme_sgw_remove(sgw);
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
mme_sgw_t *mme_sgw_find_by_addr(const ogs_sockaddr_t *addr)
|
2019-11-07 14:07:29 +00:00
|
|
|
{
|
|
|
|
|
mme_sgw_t *sgw = NULL;
|
|
|
|
|
|
|
|
|
|
ogs_assert(addr);
|
|
|
|
|
|
|
|
|
|
ogs_list_for_each(&self.sgw_list, sgw) {
|
2022-04-14 08:34:55 +00:00
|
|
|
if (ogs_sockaddr_is_equal(&sgw->gnode.addr, addr) == true)
|
2019-11-07 14:07:29 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return sgw;
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-05 12:13:18 +00:00
|
|
|
mme_pgw_t *mme_pgw_add(ogs_sockaddr_t *addr)
|
2018-09-23 04:16:40 +00:00
|
|
|
{
|
|
|
|
|
mme_pgw_t *pgw = NULL;
|
|
|
|
|
|
2019-06-05 12:13:18 +00:00
|
|
|
ogs_assert(addr);
|
2018-09-23 04:16:40 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_pool_alloc(&mme_pgw_pool, &pgw);
|
|
|
|
|
ogs_assert(pgw);
|
2019-10-27 08:41:14 +00:00
|
|
|
memset(pgw, 0, sizeof *pgw);
|
2018-09-23 04:16:40 +00:00
|
|
|
|
2022-04-14 08:34:55 +00:00
|
|
|
pgw->sa_list = addr;
|
2019-06-05 12:13:18 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_list_add(&self.pgw_list, pgw);
|
2018-09-23 04:16:40 +00:00
|
|
|
|
|
|
|
|
return pgw;
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-30 10:58:27 +00:00
|
|
|
void mme_pgw_remove(mme_pgw_t *pgw)
|
2018-09-23 04:16:40 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(pgw);
|
2018-09-23 04:16:40 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_list_remove(&self.pgw_list, pgw);
|
2018-09-23 04:16:40 +00:00
|
|
|
|
2022-04-14 08:34:55 +00:00
|
|
|
ogs_freeaddrinfo(pgw->sa_list);
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_pool_free(&mme_pgw_pool, pgw);
|
2018-09-23 04:16:40 +00:00
|
|
|
}
|
|
|
|
|
|
2023-04-04 12:53:39 +00:00
|
|
|
void mme_pgw_remove_all(void)
|
2018-09-23 04:16:40 +00:00
|
|
|
{
|
|
|
|
|
mme_pgw_t *pgw = NULL, *next_pgw = NULL;
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_list_for_each_safe(&self.pgw_list, next_pgw, pgw)
|
2018-09-23 04:16:40 +00:00
|
|
|
mme_pgw_remove(pgw);
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-04 10:11:19 +00:00
|
|
|
static bool compare_apn_enb_info(
|
2024-01-05 18:25:53 +00:00
|
|
|
const mme_pgw_t *pgw, const mme_sess_t *sess)
|
2023-05-04 10:11:19 +00:00
|
|
|
{
|
|
|
|
|
mme_ue_t *mme_ue = NULL;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
ogs_assert(pgw);
|
|
|
|
|
ogs_assert(sess);
|
|
|
|
|
ogs_assert(sess->session);
|
|
|
|
|
ogs_assert(sess->session->name);
|
|
|
|
|
mme_ue = sess->mme_ue;
|
|
|
|
|
ogs_assert(mme_ue);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < pgw->num_of_apn; i++)
|
|
|
|
|
if (!ogs_strcasecmp(pgw->apn[i], sess->session->name)) return true;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < pgw->num_of_e_cell_id; i++)
|
|
|
|
|
if (pgw->e_cell_id[i] == mme_ue->e_cgi.cell_id) return true;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < pgw->num_of_tac; i++)
|
|
|
|
|
if (pgw->tac[i] == mme_ue->tai.tac) return true;
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ogs_sockaddr_t *mme_pgw_addr_find_by_apn_enb(
|
2024-01-05 18:25:53 +00:00
|
|
|
ogs_list_t *list, int family, const mme_sess_t *sess)
|
2019-05-18 15:24:15 +00:00
|
|
|
{
|
|
|
|
|
mme_pgw_t *pgw = NULL;
|
|
|
|
|
ogs_assert(list);
|
|
|
|
|
|
|
|
|
|
ogs_list_for_each(list, pgw) {
|
2022-04-14 08:34:55 +00:00
|
|
|
ogs_assert(pgw->sa_list);
|
|
|
|
|
ogs_sockaddr_t *addr = pgw->sa_list;
|
2019-05-18 15:24:15 +00:00
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
while (addr) {
|
2019-05-30 04:50:53 +00:00
|
|
|
if (addr->ogs_sa_family == family &&
|
2023-05-04 10:11:19 +00:00
|
|
|
(!sess || compare_apn_enb_info(pgw, sess))) {
|
2019-05-18 15:24:15 +00:00
|
|
|
return addr;
|
|
|
|
|
}
|
|
|
|
|
addr = addr->next;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2022-03-15 13:03:50 +00:00
|
|
|
mme_vlr_t *mme_vlr_add(ogs_sockaddr_t *sa_list, ogs_sockopt_t *option)
|
2019-06-02 12:55:24 +00:00
|
|
|
{
|
|
|
|
|
mme_vlr_t *vlr = NULL;
|
|
|
|
|
|
2019-06-17 01:36:44 +00:00
|
|
|
ogs_assert(sa_list);
|
2019-06-02 12:55:24 +00:00
|
|
|
|
|
|
|
|
ogs_pool_alloc(&mme_vlr_pool, &vlr);
|
|
|
|
|
ogs_assert(vlr);
|
|
|
|
|
memset(vlr, 0, sizeof *vlr);
|
|
|
|
|
|
2021-04-01 06:40:46 +00:00
|
|
|
vlr->max_num_of_ostreams = OGS_DEFAULT_SCTP_MAX_NUM_OF_OSTREAMS;
|
2019-06-26 14:06:31 +00:00
|
|
|
vlr->ostream_id = 0;
|
|
|
|
|
|
2019-06-17 01:36:44 +00:00
|
|
|
vlr->sa_list = sa_list;
|
2022-03-15 13:03:50 +00:00
|
|
|
if (option) {
|
|
|
|
|
vlr->max_num_of_ostreams = option->sctp.sinit_num_ostreams;
|
|
|
|
|
vlr->option = ogs_memdup(option, sizeof *option);
|
|
|
|
|
}
|
2019-06-05 13:23:45 +00:00
|
|
|
|
2019-06-02 12:55:24 +00:00
|
|
|
ogs_list_add(&self.vlr_list, vlr);
|
|
|
|
|
|
|
|
|
|
return vlr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void mme_vlr_remove(mme_vlr_t *vlr)
|
|
|
|
|
{
|
|
|
|
|
ogs_assert(vlr);
|
|
|
|
|
|
|
|
|
|
ogs_list_remove(&self.vlr_list, vlr);
|
|
|
|
|
|
2019-10-31 05:17:43 +00:00
|
|
|
mme_vlr_close(vlr);
|
2019-06-17 01:36:44 +00:00
|
|
|
|
|
|
|
|
ogs_freeaddrinfo(vlr->sa_list);
|
2022-03-15 13:03:50 +00:00
|
|
|
if (vlr->option)
|
|
|
|
|
ogs_free(vlr->option);
|
2019-06-16 08:33:45 +00:00
|
|
|
|
2019-06-02 12:55:24 +00:00
|
|
|
ogs_pool_free(&mme_vlr_pool, vlr);
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-04 12:53:39 +00:00
|
|
|
void mme_vlr_remove_all(void)
|
2019-06-02 12:55:24 +00:00
|
|
|
{
|
|
|
|
|
mme_vlr_t *vlr = NULL, *next_vlr = NULL;
|
|
|
|
|
|
|
|
|
|
ogs_list_for_each_safe(&self.vlr_list, next_vlr, vlr)
|
|
|
|
|
mme_vlr_remove(vlr);
|
|
|
|
|
}
|
2019-05-18 15:24:15 +00:00
|
|
|
|
2019-10-31 05:17:43 +00:00
|
|
|
void mme_vlr_close(mme_vlr_t *vlr)
|
2019-06-17 01:36:44 +00:00
|
|
|
{
|
|
|
|
|
ogs_assert(vlr);
|
|
|
|
|
|
2019-10-31 05:17:43 +00:00
|
|
|
if (vlr->poll)
|
|
|
|
|
ogs_pollset_remove(vlr->poll);
|
|
|
|
|
if (vlr->sock)
|
|
|
|
|
ogs_sctp_destroy(vlr->sock);
|
2019-06-17 01:36:44 +00:00
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
mme_vlr_t *mme_vlr_find_by_addr(const ogs_sockaddr_t *addr)
|
2019-06-16 12:26:22 +00:00
|
|
|
{
|
|
|
|
|
mme_vlr_t *vlr = NULL;
|
|
|
|
|
ogs_assert(addr);
|
|
|
|
|
|
|
|
|
|
ogs_list_for_each(&self.vlr_list, vlr) {
|
2019-06-16 13:17:38 +00:00
|
|
|
if (ogs_sockaddr_is_equal(vlr->addr, addr) == true)
|
2019-06-16 12:26:22 +00:00
|
|
|
return vlr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-21 11:06:08 +00:00
|
|
|
mme_csmap_t *mme_csmap_add(mme_vlr_t *vlr)
|
|
|
|
|
{
|
|
|
|
|
mme_csmap_t *csmap = NULL;
|
|
|
|
|
|
|
|
|
|
ogs_assert(vlr);
|
|
|
|
|
|
|
|
|
|
ogs_pool_alloc(&mme_csmap_pool, &csmap);
|
|
|
|
|
ogs_assert(csmap);
|
|
|
|
|
memset(csmap, 0, sizeof *csmap);
|
|
|
|
|
|
|
|
|
|
csmap->vlr = vlr;
|
|
|
|
|
|
|
|
|
|
ogs_list_add(&self.csmap_list, csmap);
|
|
|
|
|
|
|
|
|
|
return csmap;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void mme_csmap_remove(mme_csmap_t *csmap)
|
|
|
|
|
{
|
|
|
|
|
ogs_assert(csmap);
|
|
|
|
|
|
|
|
|
|
ogs_list_remove(&self.csmap_list, csmap);
|
|
|
|
|
|
|
|
|
|
ogs_pool_free(&mme_csmap_pool, csmap);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void mme_csmap_remove_all(void)
|
|
|
|
|
{
|
|
|
|
|
mme_csmap_t *csmap = NULL, *next_csmap = NULL;
|
|
|
|
|
|
|
|
|
|
ogs_list_for_each_safe(&self.csmap_list, next_csmap, csmap)
|
|
|
|
|
mme_csmap_remove(csmap);
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
mme_csmap_t *mme_csmap_find_by_tai(const ogs_eps_tai_t *tai)
|
2019-07-21 11:06:08 +00:00
|
|
|
{
|
|
|
|
|
mme_csmap_t *csmap = NULL;
|
|
|
|
|
ogs_assert(tai);
|
|
|
|
|
|
|
|
|
|
ogs_list_for_each(&self.csmap_list, csmap) {
|
2020-05-25 16:15:22 +00:00
|
|
|
ogs_nas_eps_tai_t ogs_nas_tai;
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_nas_from_plmn_id(&ogs_nas_tai.nas_plmn_id, &tai->plmn_id);
|
|
|
|
|
ogs_nas_tai.tac = tai->tac;
|
2020-05-25 16:15:22 +00:00
|
|
|
if (memcmp(&csmap->tai, &ogs_nas_tai, sizeof(ogs_nas_eps_tai_t)) == 0)
|
2019-07-21 11:06:08 +00:00
|
|
|
return csmap;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
mme_csmap_t *mme_csmap_find_by_nas_lai(const ogs_nas_lai_t *lai)
|
2019-07-21 11:06:08 +00:00
|
|
|
{
|
|
|
|
|
mme_csmap_t *csmap = NULL;
|
|
|
|
|
ogs_assert(lai);
|
|
|
|
|
|
|
|
|
|
ogs_list_for_each(&self.csmap_list, csmap) {
|
|
|
|
|
if (memcmp(&csmap->lai, lai, sizeof *lai) == 0)
|
|
|
|
|
return csmap;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
mme_enb_t *mme_enb_add(ogs_sock_t *sock, ogs_sockaddr_t *addr)
|
2017-02-13 04:19:53 +00:00
|
|
|
{
|
2017-04-06 11:10:00 +00:00
|
|
|
mme_enb_t *enb = NULL;
|
2019-04-27 14:54:30 +00:00
|
|
|
mme_event_t e;
|
2017-02-13 04:19:53 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(sock);
|
|
|
|
|
ogs_assert(addr);
|
2017-11-24 02:49:37 +00:00
|
|
|
|
2020-04-27 02:18:47 +00:00
|
|
|
ogs_pool_alloc(&mme_enb_pool, &enb);
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(enb);
|
2020-04-27 02:18:47 +00:00
|
|
|
memset(enb, 0, sizeof *enb);
|
2017-04-11 00:19:33 +00:00
|
|
|
|
2020-11-11 18:21:32 +00:00
|
|
|
enb->sctp.sock = sock;
|
|
|
|
|
enb->sctp.addr = addr;
|
|
|
|
|
enb->sctp.type = mme_enb_sock_type(enb->sctp.sock);
|
|
|
|
|
|
|
|
|
|
if (enb->sctp.type == SOCK_STREAM) {
|
|
|
|
|
enb->sctp.poll.read = ogs_pollset_add(ogs_app()->pollset,
|
|
|
|
|
OGS_POLLIN, sock->fd, s1ap_recv_upcall, sock);
|
|
|
|
|
ogs_assert(enb->sctp.poll.read);
|
|
|
|
|
|
|
|
|
|
ogs_list_init(&enb->sctp.write_queue);
|
|
|
|
|
}
|
2017-11-24 02:49:37 +00:00
|
|
|
|
2022-03-15 13:03:50 +00:00
|
|
|
enb->max_num_of_ostreams = 0;
|
2019-06-26 14:06:31 +00:00
|
|
|
enb->ostream_id = 0;
|
2019-04-27 14:54:30 +00:00
|
|
|
|
|
|
|
|
ogs_list_init(&enb->enb_ue_list);
|
2018-05-18 08:14:29 +00:00
|
|
|
|
2020-11-11 18:21:32 +00:00
|
|
|
ogs_hash_set(self.enb_addr_hash,
|
|
|
|
|
enb->sctp.addr, sizeof(ogs_sockaddr_t), enb);
|
2017-04-08 01:45:48 +00:00
|
|
|
|
2020-06-22 03:07:14 +00:00
|
|
|
memset(&e, 0, sizeof(e));
|
2019-04-27 14:54:30 +00:00
|
|
|
e.enb = enb;
|
2022-08-12 05:03:53 +00:00
|
|
|
ogs_fsm_init(&enb->sm, s1ap_state_initial, s1ap_state_final, &e);
|
2017-10-18 05:36:12 +00:00
|
|
|
|
2019-07-08 12:03:39 +00:00
|
|
|
ogs_list_add(&self.enb_list, enb);
|
2022-06-08 21:23:51 +00:00
|
|
|
mme_metrics_inst_global_inc(MME_METR_GLOB_GAUGE_ENB);
|
2019-07-08 12:03:39 +00:00
|
|
|
|
2020-09-05 03:36:51 +00:00
|
|
|
ogs_info("[Added] Number of eNBs is now %d",
|
|
|
|
|
ogs_list_count(&self.enb_list));
|
2019-11-05 06:23:33 +00:00
|
|
|
|
2017-02-13 04:19:53 +00:00
|
|
|
return enb;
|
|
|
|
|
}
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
int mme_enb_remove(mme_enb_t *enb)
|
2017-02-13 04:19:53 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
mme_event_t e;
|
2017-09-03 15:06:39 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(enb);
|
2020-11-11 18:21:32 +00:00
|
|
|
ogs_assert(enb->sctp.sock);
|
2017-10-18 05:05:22 +00:00
|
|
|
|
2019-07-08 12:03:39 +00:00
|
|
|
ogs_list_remove(&self.enb_list, enb);
|
|
|
|
|
|
2020-06-22 03:07:14 +00:00
|
|
|
memset(&e, 0, sizeof(e));
|
2019-04-27 14:54:30 +00:00
|
|
|
e.enb = enb;
|
|
|
|
|
ogs_fsm_fini(&enb->sm, &e);
|
2017-10-18 05:36:12 +00:00
|
|
|
|
2020-11-11 18:21:32 +00:00
|
|
|
ogs_hash_set(self.enb_addr_hash,
|
|
|
|
|
enb->sctp.addr, sizeof(ogs_sockaddr_t), NULL);
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_hash_set(self.enb_id_hash, &enb->enb_id, sizeof(enb->enb_id), NULL);
|
2017-02-13 04:19:53 +00:00
|
|
|
|
2021-01-25 04:43:42 +00:00
|
|
|
/*
|
|
|
|
|
* CHECK:
|
|
|
|
|
*
|
|
|
|
|
* S1-Reset Ack buffer is not cleared at this point.
|
|
|
|
|
* ogs_sctp_flush_and_destroy will clear this buffer
|
|
|
|
|
*/
|
|
|
|
|
|
2020-11-11 18:21:32 +00:00
|
|
|
ogs_sctp_flush_and_destroy(&enb->sctp);
|
2020-04-27 02:18:47 +00:00
|
|
|
|
|
|
|
|
ogs_pool_free(&mme_enb_pool, enb);
|
2022-06-08 21:23:51 +00:00
|
|
|
mme_metrics_inst_global_dec(MME_METR_GLOB_GAUGE_ENB);
|
2020-09-05 03:36:51 +00:00
|
|
|
ogs_info("[Removed] Number of eNBs is now %d",
|
|
|
|
|
ogs_list_count(&self.enb_list));
|
2019-11-05 06:23:33 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_OK;
|
2017-02-13 04:19:53 +00:00
|
|
|
}
|
|
|
|
|
|
2023-04-04 12:53:39 +00:00
|
|
|
int mme_enb_remove_all(void)
|
2017-02-13 04:19:53 +00:00
|
|
|
{
|
2019-07-08 12:03:39 +00:00
|
|
|
mme_enb_t *enb = NULL, *next_enb = NULL;
|
2017-02-13 04:19:53 +00:00
|
|
|
|
2019-07-08 12:03:39 +00:00
|
|
|
ogs_list_for_each_safe(&self.enb_list, next_enb, enb)
|
2017-04-06 11:10:00 +00:00
|
|
|
mme_enb_remove(enb);
|
2017-02-13 04:19:53 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_OK;
|
2017-02-13 04:19:53 +00:00
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
mme_enb_t *mme_enb_find_by_addr(const ogs_sockaddr_t *addr)
|
2017-11-24 02:49:37 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(addr);
|
|
|
|
|
return (mme_enb_t *)ogs_hash_get(self.enb_addr_hash,
|
|
|
|
|
addr, sizeof(ogs_sockaddr_t));
|
2017-02-13 04:19:53 +00:00
|
|
|
|
2017-10-18 05:05:22 +00:00
|
|
|
return NULL;
|
2017-02-13 04:19:53 +00:00
|
|
|
}
|
|
|
|
|
|
2019-06-30 11:29:25 +00:00
|
|
|
mme_enb_t *mme_enb_find_by_enb_id(uint32_t enb_id)
|
2017-02-13 04:19:53 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
return (mme_enb_t *)ogs_hash_get(self.enb_id_hash, &enb_id, sizeof(enb_id));
|
2017-10-18 05:05:22 +00:00
|
|
|
}
|
2017-02-13 04:19:53 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
int mme_enb_set_enb_id(mme_enb_t *enb, uint32_t enb_id)
|
2017-10-18 05:05:22 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(enb);
|
2017-02-13 04:19:53 +00:00
|
|
|
|
2022-01-31 13:58:52 +00:00
|
|
|
ogs_hash_set(self.enb_id_hash, &enb_id, sizeof(enb_id), NULL);
|
|
|
|
|
|
2017-10-18 05:05:22 +00:00
|
|
|
enb->enb_id = enb_id;
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_hash_set(self.enb_id_hash, &enb->enb_id, sizeof(enb->enb_id), enb);
|
2017-10-18 05:05:22 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_OK;
|
2017-10-18 05:05:22 +00:00
|
|
|
}
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
int mme_enb_sock_type(ogs_sock_t *sock)
|
2017-11-24 02:49:37 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_socknode_t *snode = NULL;
|
2017-11-24 15:52:07 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(sock);
|
2017-11-24 15:52:07 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_list_for_each(&mme_self()->s1ap_list, snode)
|
2017-12-08 03:43:35 +00:00
|
|
|
if (snode->sock == sock) return SOCK_SEQPACKET;
|
2019-04-27 14:54:30 +00:00
|
|
|
|
|
|
|
|
ogs_list_for_each(&mme_self()->s1ap_list6, snode)
|
2017-12-08 03:43:35 +00:00
|
|
|
if (snode->sock == sock) return SOCK_SEQPACKET;
|
2017-11-24 15:52:07 +00:00
|
|
|
|
|
|
|
|
return SOCK_STREAM;
|
2017-11-24 02:49:37 +00:00
|
|
|
}
|
|
|
|
|
|
2022-08-19 09:58:55 +00:00
|
|
|
mme_enb_t *mme_enb_cycle(mme_enb_t *enb)
|
|
|
|
|
{
|
|
|
|
|
return ogs_pool_cycle(&mme_enb_pool, enb);
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-28 04:43:42 +00:00
|
|
|
/** enb_ue_context handling function */
|
2019-12-13 04:49:20 +00:00
|
|
|
enb_ue_t *enb_ue_add(mme_enb_t *enb, uint32_t enb_ue_s1ap_id)
|
2017-03-05 04:03:11 +00:00
|
|
|
{
|
2017-04-28 07:11:45 +00:00
|
|
|
enb_ue_t *enb_ue = NULL;
|
2017-03-05 04:03:11 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(enb);
|
2017-03-05 04:03:11 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_pool_alloc(&enb_ue_pool, &enb_ue);
|
2022-10-11 08:44:55 +00:00
|
|
|
if (enb_ue == NULL) {
|
|
|
|
|
ogs_error("Could not allocate enb_ue context from pool");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-27 08:41:14 +00:00
|
|
|
memset(enb_ue, 0, sizeof *enb_ue);
|
2017-03-05 04:03:11 +00:00
|
|
|
|
2022-09-03 06:59:39 +00:00
|
|
|
enb_ue->t_s1_holding = ogs_timer_add(
|
|
|
|
|
ogs_app()->timer_mgr, mme_timer_s1_holding_timer_expire, enb_ue);
|
|
|
|
|
if (!enb_ue->t_s1_holding) {
|
|
|
|
|
ogs_error("ogs_timer_add() failed");
|
|
|
|
|
ogs_pool_free(&enb_ue_pool, enb_ue);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-30 03:27:54 +00:00
|
|
|
enb_ue->index = ogs_pool_index(&enb_ue_pool, enb_ue);
|
2023-11-19 10:34:51 +00:00
|
|
|
ogs_assert(enb_ue->index > 0 && enb_ue->index <= ogs_global_conf()->max.ue);
|
2020-08-30 03:27:54 +00:00
|
|
|
|
2019-12-13 04:46:22 +00:00
|
|
|
enb_ue->enb_ue_s1ap_id = enb_ue_s1ap_id;
|
2020-08-30 03:27:54 +00:00
|
|
|
enb_ue->mme_ue_s1ap_id = enb_ue->index;
|
2019-06-28 09:11:16 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* SCTP output stream identification
|
2023-11-19 10:34:51 +00:00
|
|
|
* Default ogs_global_conf()->parameter.sctp_streams : 30
|
2019-06-28 09:11:16 +00:00
|
|
|
* 0 : Non UE signalling
|
2022-03-01 08:13:40 +00:00
|
|
|
* 1-29 : UE specific association
|
2019-06-28 09:11:16 +00:00
|
|
|
*/
|
2022-03-15 13:03:50 +00:00
|
|
|
ogs_assert((enb->max_num_of_ostreams-1) >= 1); /* NEXT_ID(MAX >= MIN) */
|
2022-03-01 08:13:40 +00:00
|
|
|
enb_ue->enb_ostream_id =
|
2019-09-13 12:07:47 +00:00
|
|
|
OGS_NEXT_ID(enb->ostream_id, 1, enb->max_num_of_ostreams-1);
|
2019-06-28 09:11:16 +00:00
|
|
|
|
2017-11-09 05:56:03 +00:00
|
|
|
enb_ue->enb = enb;
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_list_add(&enb->enb_ue_list, enb_ue);
|
2018-02-02 10:37:36 +00:00
|
|
|
|
2020-09-05 03:36:51 +00:00
|
|
|
stats_add_enb_ue();
|
2019-11-05 06:23:33 +00:00
|
|
|
|
2017-04-28 07:11:45 +00:00
|
|
|
return enb_ue;
|
2017-03-05 04:03:11 +00:00
|
|
|
}
|
|
|
|
|
|
2019-06-30 11:46:15 +00:00
|
|
|
void enb_ue_remove(enb_ue_t *enb_ue)
|
2017-03-05 04:03:11 +00:00
|
|
|
{
|
2020-09-05 03:36:51 +00:00
|
|
|
mme_enb_t *enb = NULL;
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(enb_ue);
|
2020-09-05 03:36:51 +00:00
|
|
|
enb = enb_ue->enb;
|
|
|
|
|
ogs_assert(enb);
|
2017-03-05 04:03:11 +00:00
|
|
|
|
2020-09-05 03:36:51 +00:00
|
|
|
ogs_list_remove(&enb->enb_ue_list, enb_ue);
|
2017-04-06 12:44:30 +00:00
|
|
|
|
2021-01-28 19:23:54 +00:00
|
|
|
ogs_assert(enb_ue->t_s1_holding);
|
|
|
|
|
ogs_timer_delete(enb_ue->t_s1_holding);
|
2020-09-03 23:59:00 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_pool_free(&enb_ue_pool, enb_ue);
|
2020-09-05 03:36:51 +00:00
|
|
|
|
|
|
|
|
stats_remove_enb_ue();
|
2017-04-28 04:43:42 +00:00
|
|
|
}
|
|
|
|
|
|
2019-06-30 11:46:15 +00:00
|
|
|
void enb_ue_switch_to_enb(enb_ue_t *enb_ue, mme_enb_t *new_enb)
|
2017-09-15 21:02:14 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(enb_ue);
|
|
|
|
|
ogs_assert(enb_ue->enb);
|
|
|
|
|
ogs_assert(new_enb);
|
2017-09-15 21:02:14 +00:00
|
|
|
|
|
|
|
|
/* Remove from the old enb */
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_list_remove(&enb_ue->enb->enb_ue_list, enb_ue);
|
2017-09-15 21:02:14 +00:00
|
|
|
|
|
|
|
|
/* Add to the new enb */
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_list_add(&new_enb->enb_ue_list, enb_ue);
|
2017-09-15 21:02:14 +00:00
|
|
|
|
|
|
|
|
/* Switch to enb */
|
|
|
|
|
enb_ue->enb = new_enb;
|
2017-04-28 04:43:42 +00:00
|
|
|
}
|
|
|
|
|
|
2019-06-30 11:29:25 +00:00
|
|
|
enb_ue_t *enb_ue_find_by_enb_ue_s1ap_id(
|
2024-01-05 18:25:53 +00:00
|
|
|
const mme_enb_t *enb, uint32_t enb_ue_s1ap_id)
|
2017-04-28 04:43:42 +00:00
|
|
|
{
|
2017-04-28 07:11:45 +00:00
|
|
|
enb_ue_t *enb_ue = NULL;
|
2022-03-01 08:13:40 +00:00
|
|
|
|
2020-11-07 22:27:12 +00:00
|
|
|
ogs_list_for_each(&enb->enb_ue_list, enb_ue) {
|
2017-04-28 07:11:45 +00:00
|
|
|
if (enb_ue_s1ap_id == enb_ue->enb_ue_s1ap_id)
|
2017-04-28 04:43:42 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-28 07:11:45 +00:00
|
|
|
return enb_ue;
|
2017-04-28 04:43:42 +00:00
|
|
|
}
|
|
|
|
|
|
2020-08-30 03:27:54 +00:00
|
|
|
enb_ue_t *enb_ue_find(uint32_t index)
|
|
|
|
|
{
|
|
|
|
|
return ogs_pool_find(&enb_ue_pool, index);
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-30 11:29:25 +00:00
|
|
|
enb_ue_t *enb_ue_find_by_mme_ue_s1ap_id(uint32_t mme_ue_s1ap_id)
|
2017-04-28 04:43:42 +00:00
|
|
|
{
|
2020-08-30 03:27:54 +00:00
|
|
|
return enb_ue_find(mme_ue_s1ap_id);
|
2017-04-28 04:43:42 +00:00
|
|
|
}
|
|
|
|
|
|
2020-10-29 02:59:27 +00:00
|
|
|
enb_ue_t *enb_ue_cycle(enb_ue_t *enb_ue)
|
|
|
|
|
{
|
|
|
|
|
return ogs_pool_cycle(&enb_ue_pool, enb_ue);
|
|
|
|
|
}
|
|
|
|
|
|
2022-04-29 12:28:16 +00:00
|
|
|
/** sgw_ue_context handling function */
|
|
|
|
|
sgw_ue_t *sgw_ue_add(mme_sgw_t *sgw)
|
|
|
|
|
{
|
|
|
|
|
sgw_ue_t *sgw_ue = NULL;
|
|
|
|
|
|
|
|
|
|
ogs_assert(sgw);
|
|
|
|
|
|
|
|
|
|
ogs_pool_alloc(&sgw_ue_pool, &sgw_ue);
|
|
|
|
|
ogs_assert(sgw_ue);
|
|
|
|
|
memset(sgw_ue, 0, sizeof *sgw_ue);
|
|
|
|
|
|
2022-05-12 13:52:36 +00:00
|
|
|
sgw_ue->t_s11_holding = ogs_timer_add(
|
2022-04-29 12:28:16 +00:00
|
|
|
ogs_app()->timer_mgr, mme_timer_s11_holding_timer_expire, sgw_ue);
|
2022-09-03 06:59:39 +00:00
|
|
|
if (!sgw_ue->t_s11_holding) {
|
|
|
|
|
ogs_error("ogs_timer_add() failed");
|
|
|
|
|
ogs_pool_free(&sgw_ue_pool, sgw_ue);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2022-04-29 12:28:16 +00:00
|
|
|
|
|
|
|
|
sgw_ue->sgw = sgw;
|
|
|
|
|
|
|
|
|
|
ogs_list_add(&sgw->sgw_ue_list, sgw_ue);
|
|
|
|
|
|
|
|
|
|
return sgw_ue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void sgw_ue_remove(sgw_ue_t *sgw_ue)
|
|
|
|
|
{
|
|
|
|
|
mme_sgw_t *sgw = NULL;
|
|
|
|
|
|
|
|
|
|
ogs_assert(sgw_ue);
|
|
|
|
|
sgw = sgw_ue->sgw;
|
|
|
|
|
ogs_assert(sgw);
|
|
|
|
|
|
|
|
|
|
ogs_list_remove(&sgw->sgw_ue_list, sgw_ue);
|
|
|
|
|
|
2022-05-12 13:52:36 +00:00
|
|
|
ogs_assert(sgw_ue->t_s11_holding);
|
|
|
|
|
ogs_timer_delete(sgw_ue->t_s11_holding);
|
2022-04-29 12:28:16 +00:00
|
|
|
|
|
|
|
|
ogs_pool_free(&sgw_ue_pool, sgw_ue);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void sgw_ue_switch_to_sgw(sgw_ue_t *sgw_ue, mme_sgw_t *new_sgw)
|
|
|
|
|
{
|
|
|
|
|
ogs_assert(sgw_ue);
|
|
|
|
|
ogs_assert(sgw_ue->sgw);
|
|
|
|
|
ogs_assert(new_sgw);
|
|
|
|
|
|
|
|
|
|
/* Remove from the old sgw */
|
|
|
|
|
ogs_list_remove(&sgw_ue->sgw->sgw_ue_list, sgw_ue);
|
|
|
|
|
|
|
|
|
|
/* Add to the new sgw */
|
|
|
|
|
ogs_list_add(&new_sgw->sgw_ue_list, sgw_ue);
|
|
|
|
|
|
|
|
|
|
/* Switch to sgw */
|
|
|
|
|
sgw_ue->sgw = new_sgw;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sgw_ue_t *sgw_ue_cycle(sgw_ue_t *sgw_ue)
|
|
|
|
|
{
|
|
|
|
|
return ogs_pool_cycle(&sgw_ue_pool, sgw_ue);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sgw_relocation_e sgw_ue_check_if_relocated(mme_ue_t *mme_ue)
|
|
|
|
|
{
|
|
|
|
|
enb_ue_t *enb_ue = NULL;
|
2022-05-12 13:52:36 +00:00
|
|
|
sgw_ue_t *old_source_ue = NULL, *source_ue = NULL, *target_ue = NULL;
|
2022-04-29 12:28:16 +00:00
|
|
|
mme_sgw_t *current = NULL, *changed = NULL;
|
|
|
|
|
|
|
|
|
|
ogs_assert(mme_ue);
|
|
|
|
|
enb_ue = enb_ue_cycle(mme_ue->enb_ue);
|
|
|
|
|
ogs_assert(enb_ue);
|
|
|
|
|
source_ue = sgw_ue_cycle(mme_ue->sgw_ue);
|
|
|
|
|
ogs_assert(source_ue);
|
|
|
|
|
|
|
|
|
|
current = source_ue->sgw;
|
|
|
|
|
ogs_assert(current);
|
|
|
|
|
|
|
|
|
|
changed = changed_sgw_node(current, enb_ue);
|
|
|
|
|
if (!changed) return SGW_WITHOUT_RELOCATION;
|
|
|
|
|
|
2022-05-12 13:52:36 +00:00
|
|
|
/* Check if Old Source UE */
|
|
|
|
|
old_source_ue = sgw_ue_cycle(source_ue->source_ue);
|
|
|
|
|
if (old_source_ue) {
|
|
|
|
|
sgw_ue_source_deassociate_target(old_source_ue);
|
|
|
|
|
sgw_ue_remove(old_source_ue);
|
|
|
|
|
}
|
|
|
|
|
|
2022-04-29 12:28:16 +00:00
|
|
|
target_ue = sgw_ue_cycle(source_ue->target_ue);
|
|
|
|
|
if (target_ue) {
|
|
|
|
|
ogs_error("SGW-UE source has already been associated with target");
|
|
|
|
|
return SGW_HAS_ALREADY_BEEN_RELOCATED;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
target_ue = sgw_ue_add(changed);
|
|
|
|
|
ogs_assert(target_ue);
|
|
|
|
|
|
|
|
|
|
sgw_ue_source_associate_target(source_ue, target_ue);
|
|
|
|
|
|
|
|
|
|
return SGW_WITH_RELOCATION;
|
|
|
|
|
}
|
|
|
|
|
|
2021-03-09 05:28:07 +00:00
|
|
|
void mme_ue_new_guti(mme_ue_t *mme_ue)
|
2018-01-29 22:25:42 +00:00
|
|
|
{
|
|
|
|
|
served_gummei_t *served_gummei = NULL;
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(mme_ue);
|
2023-12-03 14:52:29 +00:00
|
|
|
ogs_assert(mme_self()->num_of_served_gummei > 0);
|
2018-01-29 22:25:42 +00:00
|
|
|
|
|
|
|
|
served_gummei = &mme_self()->served_gummei[0];
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(served_gummei->num_of_plmn_id > 0);
|
|
|
|
|
ogs_assert(served_gummei->num_of_mme_gid > 0);
|
|
|
|
|
ogs_assert(served_gummei->num_of_mme_code > 0);
|
2018-01-29 22:25:42 +00:00
|
|
|
|
2021-04-13 08:34:25 +00:00
|
|
|
if (mme_ue->next.m_tmsi) {
|
|
|
|
|
ogs_warn("GUTI has already been allocated");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
memset(&mme_ue->next.guti, 0, sizeof(ogs_nas_eps_guti_t));
|
|
|
|
|
|
|
|
|
|
/* Use the first configured plmn_id and mme group id */
|
|
|
|
|
ogs_nas_from_plmn_id(
|
|
|
|
|
&mme_ue->next.guti.nas_plmn_id, &served_gummei->plmn_id[0]);
|
|
|
|
|
mme_ue->next.guti.mme_gid = served_gummei->mme_gid[0];
|
|
|
|
|
mme_ue->next.guti.mme_code = served_gummei->mme_code[0];
|
|
|
|
|
|
|
|
|
|
mme_ue->next.m_tmsi = mme_m_tmsi_alloc();
|
|
|
|
|
ogs_assert(mme_ue->next.m_tmsi);
|
|
|
|
|
mme_ue->next.guti.m_tmsi = *(mme_ue->next.m_tmsi);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void mme_ue_confirm_guti(mme_ue_t *mme_ue)
|
|
|
|
|
{
|
|
|
|
|
ogs_assert(mme_ue->next.m_tmsi);
|
|
|
|
|
|
|
|
|
|
if (mme_ue->current.m_tmsi) {
|
2019-06-30 11:29:25 +00:00
|
|
|
/* MME has a VALID GUTI
|
2018-01-29 22:25:42 +00:00
|
|
|
* As such, we need to remove previous GUTI in hash table */
|
2019-05-26 06:27:09 +00:00
|
|
|
ogs_hash_set(self.guti_ue_hash,
|
2021-04-13 08:34:25 +00:00
|
|
|
&mme_ue->current.guti, sizeof(ogs_nas_eps_guti_t), NULL);
|
|
|
|
|
ogs_assert(mme_m_tmsi_free(mme_ue->current.m_tmsi) == OGS_OK);
|
2018-01-29 22:25:42 +00:00
|
|
|
}
|
|
|
|
|
|
2024-01-02 12:14:41 +00:00
|
|
|
/* Copying from Next to Current Guti */
|
2021-04-13 08:34:25 +00:00
|
|
|
mme_ue->current.m_tmsi = mme_ue->next.m_tmsi;
|
|
|
|
|
memcpy(&mme_ue->current.guti,
|
|
|
|
|
&mme_ue->next.guti, sizeof(ogs_nas_eps_guti_t));
|
2018-01-29 22:25:42 +00:00
|
|
|
|
2021-04-13 08:34:25 +00:00
|
|
|
/* Hashing Current GUTI */
|
2020-04-27 02:18:47 +00:00
|
|
|
ogs_hash_set(self.guti_ue_hash,
|
2021-04-13 08:34:25 +00:00
|
|
|
&mme_ue->current.guti, sizeof(ogs_nas_eps_guti_t), mme_ue);
|
2018-01-29 22:25:42 +00:00
|
|
|
|
2021-04-13 08:34:25 +00:00
|
|
|
/* Clear Next GUTI */
|
|
|
|
|
mme_ue->next.m_tmsi = NULL;
|
2024-01-16 10:13:47 +00:00
|
|
|
|
|
|
|
|
ogs_debug("Confirm GUTI[G:%d,C:%d,M_TMSI:0x%x]",
|
|
|
|
|
mme_ue->current.guti.mme_gid,
|
|
|
|
|
mme_ue->current.guti.mme_code,
|
|
|
|
|
mme_ue->current.guti.m_tmsi);
|
2018-01-29 22:25:42 +00:00
|
|
|
}
|
|
|
|
|
|
2020-07-09 05:38:09 +00:00
|
|
|
static bool compare_ue_info(mme_sgw_t *node, enb_ue_t *enb_ue)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
ogs_assert(node);
|
|
|
|
|
ogs_assert(enb_ue);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < node->num_of_tac; i++)
|
|
|
|
|
if (node->tac[i] == enb_ue->saved.tai.tac) return true;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < node->num_of_e_cell_id; i++)
|
|
|
|
|
if (node->e_cell_id[i] == enb_ue->saved.e_cgi.cell_id) return true;
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static mme_sgw_t *selected_sgw_node(mme_sgw_t *current, enb_ue_t *enb_ue)
|
|
|
|
|
{
|
|
|
|
|
mme_sgw_t *next, *node;
|
|
|
|
|
|
|
|
|
|
ogs_assert(current);
|
|
|
|
|
ogs_assert(enb_ue);
|
|
|
|
|
|
|
|
|
|
next = ogs_list_next(current);
|
|
|
|
|
for (node = next; node; node = ogs_list_next(node)) {
|
|
|
|
|
if (compare_ue_info(node, enb_ue) == true) return node;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (node = ogs_list_first(&mme_self()->sgw_list);
|
|
|
|
|
node != next; node = ogs_list_next(node)) {
|
|
|
|
|
if (compare_ue_info(node, enb_ue) == true) return node;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return next ? next : ogs_list_first(&mme_self()->sgw_list);
|
|
|
|
|
}
|
|
|
|
|
|
2022-04-29 12:28:16 +00:00
|
|
|
static mme_sgw_t *changed_sgw_node(mme_sgw_t *current, enb_ue_t *enb_ue)
|
2022-04-14 08:34:55 +00:00
|
|
|
{
|
|
|
|
|
mme_sgw_t *changed = NULL;
|
|
|
|
|
|
|
|
|
|
ogs_assert(current);
|
|
|
|
|
ogs_assert(enb_ue);
|
|
|
|
|
|
|
|
|
|
changed = selected_sgw_node(current, enb_ue);
|
|
|
|
|
if (changed && changed != current &&
|
|
|
|
|
compare_ue_info(changed, enb_ue) == true) return changed;
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-30 11:29:25 +00:00
|
|
|
mme_ue_t *mme_ue_add(enb_ue_t *enb_ue)
|
2017-04-28 04:43:42 +00:00
|
|
|
{
|
2018-05-18 08:14:29 +00:00
|
|
|
mme_enb_t *enb = NULL;
|
2017-04-28 07:11:45 +00:00
|
|
|
mme_ue_t *mme_ue = NULL;
|
2022-04-29 12:28:16 +00:00
|
|
|
sgw_ue_t *sgw_ue = NULL;
|
2017-04-28 04:43:42 +00:00
|
|
|
|
MME: select SGW by RR,TAC,ENB_ID || SMF: select PFCP associated UPF by RR,TAC,APN,ENB_ID (re-worked) (#470)
* MME: select SGW by RR,TAC,ENB_ID
and enable round robin inside each option
* SMF: select PFCP associated UPF by RR,TAC,APN,ENB_ID
and enable round robin inside each option
2020-06-19 04:36:02 +00:00
|
|
|
char buf[OGS_ADDRSTRLEN];
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(enb_ue);
|
2018-05-18 08:14:29 +00:00
|
|
|
enb = enb_ue->enb;
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(enb);
|
2017-04-28 04:43:42 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_pool_alloc(&mme_ue_pool, &mme_ue);
|
2022-10-11 08:44:55 +00:00
|
|
|
if (mme_ue == NULL) {
|
|
|
|
|
ogs_error("Could not allocate mme_ue context from pool");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-27 08:41:14 +00:00
|
|
|
memset(mme_ue, 0, sizeof *mme_ue);
|
2017-04-28 04:43:42 +00:00
|
|
|
|
2022-09-03 06:59:39 +00:00
|
|
|
/* Add All Timers */
|
|
|
|
|
mme_ue->t3413.timer = ogs_timer_add(
|
|
|
|
|
ogs_app()->timer_mgr, mme_timer_t3413_expire, mme_ue);
|
|
|
|
|
if (!mme_ue->t3413.timer) {
|
|
|
|
|
ogs_error("ogs_timer_add() failed");
|
|
|
|
|
ogs_pool_free(&mme_ue_pool, mme_ue);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
mme_ue->t3413.pkbuf = NULL;
|
|
|
|
|
mme_ue->t3422.timer = ogs_timer_add(
|
|
|
|
|
ogs_app()->timer_mgr, mme_timer_t3422_expire, mme_ue);
|
|
|
|
|
if (!mme_ue->t3422.timer) {
|
|
|
|
|
ogs_error("ogs_timer_add() failed");
|
|
|
|
|
ogs_pool_free(&mme_ue_pool, mme_ue);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
mme_ue->t3422.pkbuf = NULL;
|
|
|
|
|
mme_ue->t3450.timer = ogs_timer_add(
|
|
|
|
|
ogs_app()->timer_mgr, mme_timer_t3450_expire, mme_ue);
|
|
|
|
|
if (!mme_ue->t3450.timer) {
|
|
|
|
|
ogs_error("ogs_timer_add() failed");
|
|
|
|
|
ogs_pool_free(&mme_ue_pool, mme_ue);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
mme_ue->t3450.pkbuf = NULL;
|
|
|
|
|
mme_ue->t3460.timer = ogs_timer_add(
|
|
|
|
|
ogs_app()->timer_mgr, mme_timer_t3460_expire, mme_ue);
|
|
|
|
|
if (!mme_ue->t3460.timer) {
|
|
|
|
|
ogs_error("ogs_timer_add() failed");
|
|
|
|
|
ogs_pool_free(&mme_ue_pool, mme_ue);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
mme_ue->t3460.pkbuf = NULL;
|
|
|
|
|
mme_ue->t3470.timer = ogs_timer_add(
|
|
|
|
|
ogs_app()->timer_mgr, mme_timer_t3470_expire, mme_ue);
|
|
|
|
|
if (!mme_ue->t3470.timer) {
|
|
|
|
|
ogs_error("ogs_timer_add() failed");
|
|
|
|
|
ogs_pool_free(&mme_ue_pool, mme_ue);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
mme_ue->t3470.pkbuf = NULL;
|
2023-01-26 12:22:17 +00:00
|
|
|
mme_ue->t_mobile_reachable.timer = ogs_timer_add(
|
|
|
|
|
ogs_app()->timer_mgr, mme_timer_mobile_reachable_expire, mme_ue);
|
|
|
|
|
if (!mme_ue->t_mobile_reachable.timer) {
|
|
|
|
|
ogs_error("ogs_timer_add() failed");
|
|
|
|
|
ogs_pool_free(&mme_ue_pool, mme_ue);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
mme_ue->t_mobile_reachable.pkbuf = NULL;
|
|
|
|
|
mme_ue->t_implicit_detach.timer = ogs_timer_add(
|
|
|
|
|
ogs_app()->timer_mgr, mme_timer_implicit_detach_expire, mme_ue);
|
|
|
|
|
if (!mme_ue->t_implicit_detach.timer) {
|
|
|
|
|
ogs_error("ogs_timer_add() failed");
|
|
|
|
|
ogs_pool_free(&mme_ue_pool, mme_ue);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
mme_ue->t_implicit_detach.pkbuf = NULL;
|
2022-09-03 06:59:39 +00:00
|
|
|
|
2023-12-11 16:18:11 +00:00
|
|
|
mme_ue->gn.t_gn_holding = ogs_timer_add(
|
|
|
|
|
ogs_app()->timer_mgr, mme_timer_gn_holding_timer_expire, mme_ue);
|
|
|
|
|
if (! mme_ue->gn.t_gn_holding) {
|
|
|
|
|
ogs_error("ogs_timer_add() failed");
|
|
|
|
|
ogs_pool_free(&mme_ue_pool, mme_ue);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-30 03:27:54 +00:00
|
|
|
mme_ebi_pool_init(mme_ue);
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_list_init(&mme_ue->sess_list);
|
2017-04-28 04:43:42 +00:00
|
|
|
|
2023-12-20 18:15:47 +00:00
|
|
|
/* Set MME-S11-TEID */
|
2023-04-09 01:34:19 +00:00
|
|
|
ogs_pool_alloc(&mme_s11_teid_pool, &mme_ue->mme_s11_teid_node);
|
|
|
|
|
ogs_assert(mme_ue->mme_s11_teid_node);
|
|
|
|
|
mme_ue->mme_s11_teid = *(mme_ue->mme_s11_teid_node);
|
|
|
|
|
ogs_hash_set(self.mme_s11_teid_hash,
|
|
|
|
|
&mme_ue->mme_s11_teid, sizeof(mme_ue->mme_s11_teid), mme_ue);
|
2022-05-12 13:52:36 +00:00
|
|
|
|
2023-12-20 18:15:47 +00:00
|
|
|
/* Set MME-Gn-TEID */
|
|
|
|
|
ogs_pool_alloc(&mme_gn_teid_pool, &mme_ue->gn.mme_gn_teid_node);
|
|
|
|
|
ogs_assert(mme_ue->gn.mme_gn_teid_node);
|
|
|
|
|
mme_ue->gn.mme_gn_teid = *(mme_ue->gn.mme_gn_teid_node);
|
|
|
|
|
ogs_hash_set(self.mme_gn_teid_hash,
|
|
|
|
|
&mme_ue->gn.mme_gn_teid, sizeof(mme_ue->gn.mme_gn_teid), mme_ue);
|
|
|
|
|
|
2020-07-09 05:38:09 +00:00
|
|
|
/*
|
|
|
|
|
* When used for the first time, if last node is set,
|
|
|
|
|
* the search is performed from the first SGW in a round-robin manner.
|
|
|
|
|
*/
|
MME: select SGW by RR,TAC,ENB_ID || SMF: select PFCP associated UPF by RR,TAC,APN,ENB_ID (re-worked) (#470)
* MME: select SGW by RR,TAC,ENB_ID
and enable round robin inside each option
* SMF: select PFCP associated UPF by RR,TAC,APN,ENB_ID
and enable round robin inside each option
2020-06-19 04:36:02 +00:00
|
|
|
if (mme_self()->sgw == NULL)
|
2020-07-09 05:38:09 +00:00
|
|
|
mme_self()->sgw = ogs_list_last(&mme_self()->sgw_list);
|
MME: select SGW by RR,TAC,ENB_ID || SMF: select PFCP associated UPF by RR,TAC,APN,ENB_ID (re-worked) (#470)
* MME: select SGW by RR,TAC,ENB_ID
and enable round robin inside each option
* SMF: select PFCP associated UPF by RR,TAC,APN,ENB_ID
and enable round robin inside each option
2020-06-19 04:36:02 +00:00
|
|
|
|
2020-07-09 05:38:09 +00:00
|
|
|
/* setup GTP path with selected SGW */
|
2022-04-29 12:28:16 +00:00
|
|
|
mme_self()->sgw = selected_sgw_node(mme_self()->sgw, enb_ue);
|
|
|
|
|
ogs_assert(mme_self()->sgw);
|
|
|
|
|
|
|
|
|
|
sgw_ue = sgw_ue_add(mme_self()->sgw);
|
|
|
|
|
ogs_assert(sgw_ue);
|
|
|
|
|
ogs_assert(sgw_ue->gnode);
|
|
|
|
|
|
|
|
|
|
sgw_ue_associate_mme_ue(sgw_ue, mme_ue);
|
|
|
|
|
|
|
|
|
|
ogs_debug("UE using SGW on IP[%s]", OGS_ADDR(sgw_ue->gnode->sa_list, buf));
|
MME: select SGW by RR,TAC,ENB_ID || SMF: select PFCP associated UPF by RR,TAC,APN,ENB_ID (re-worked) (#470)
* MME: select SGW by RR,TAC,ENB_ID
and enable round robin inside each option
* SMF: select PFCP associated UPF by RR,TAC,APN,ENB_ID
and enable round robin inside each option
2020-06-19 04:36:02 +00:00
|
|
|
|
2019-06-16 07:47:20 +00:00
|
|
|
/* Clear VLR */
|
2019-07-21 11:25:29 +00:00
|
|
|
mme_ue->csmap = NULL;
|
2019-06-16 07:47:20 +00:00
|
|
|
mme_ue->vlr_ostream_id = 0;
|
|
|
|
|
|
2020-09-21 18:37:17 +00:00
|
|
|
mme_ue_fsm_init(mme_ue);
|
2017-09-14 10:55:21 +00:00
|
|
|
|
2019-06-30 11:46:15 +00:00
|
|
|
ogs_list_add(&self.mme_ue_list, mme_ue);
|
|
|
|
|
|
2020-09-05 03:36:51 +00:00
|
|
|
ogs_info("[Added] Number of MME-UEs is now %d",
|
|
|
|
|
ogs_list_count(&self.mme_ue_list));
|
|
|
|
|
|
2017-04-28 07:11:45 +00:00
|
|
|
return mme_ue;
|
2017-04-28 04:43:42 +00:00
|
|
|
}
|
|
|
|
|
|
2019-06-30 11:46:15 +00:00
|
|
|
void mme_ue_remove(mme_ue_t *mme_ue)
|
2017-04-28 04:43:42 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(mme_ue);
|
2017-03-05 04:03:11 +00:00
|
|
|
|
2019-06-30 11:46:15 +00:00
|
|
|
ogs_list_remove(&self.mme_ue_list, mme_ue);
|
|
|
|
|
|
2020-09-21 18:37:17 +00:00
|
|
|
mme_ue_fsm_fini(mme_ue);
|
2017-04-28 04:43:42 +00:00
|
|
|
|
2023-04-09 01:34:19 +00:00
|
|
|
ogs_hash_set(self.mme_s11_teid_hash,
|
|
|
|
|
&mme_ue->mme_s11_teid, sizeof(mme_ue->mme_s11_teid), NULL);
|
2023-12-20 18:15:47 +00:00
|
|
|
ogs_hash_set(self.mme_gn_teid_hash,
|
|
|
|
|
&mme_ue->gn.mme_gn_teid, sizeof(mme_ue->gn.mme_gn_teid), NULL);
|
2023-04-09 01:34:19 +00:00
|
|
|
|
2022-04-29 12:28:16 +00:00
|
|
|
ogs_assert(mme_ue->sgw_ue);
|
|
|
|
|
sgw_ue_remove(mme_ue->sgw_ue);
|
|
|
|
|
|
2023-02-20 11:49:48 +00:00
|
|
|
if (mme_ue->imsi_len != 0)
|
|
|
|
|
ogs_hash_set(mme_self()->imsi_ue_hash,
|
|
|
|
|
mme_ue->imsi, mme_ue->imsi_len, NULL);
|
|
|
|
|
|
|
|
|
|
if (mme_ue->current.m_tmsi) {
|
|
|
|
|
ogs_hash_set(self.guti_ue_hash,
|
|
|
|
|
&mme_ue->current.guti, sizeof(ogs_nas_eps_guti_t), NULL);
|
2021-04-13 08:34:25 +00:00
|
|
|
ogs_assert(mme_m_tmsi_free(mme_ue->current.m_tmsi) == OGS_OK);
|
2023-02-20 11:49:48 +00:00
|
|
|
}
|
2022-01-31 13:58:52 +00:00
|
|
|
|
|
|
|
|
if (mme_ue->next.m_tmsi)
|
2021-04-13 08:34:25 +00:00
|
|
|
ogs_assert(mme_m_tmsi_free(mme_ue->next.m_tmsi) == OGS_OK);
|
2022-01-31 13:58:52 +00:00
|
|
|
|
2017-09-08 07:46:37 +00:00
|
|
|
/* Clear the saved PDN Connectivity Request */
|
2019-09-13 12:07:47 +00:00
|
|
|
OGS_NAS_CLEAR_DATA(&mme_ue->pdn_connectivity_request);
|
2017-09-03 02:48:41 +00:00
|
|
|
|
2019-07-14 02:00:11 +00:00
|
|
|
/* Clear Service Indicator */
|
|
|
|
|
CLEAR_SERVICE_INDICATOR(mme_ue);
|
2017-07-27 12:50:55 +00:00
|
|
|
|
2017-08-08 19:01:08 +00:00
|
|
|
/* Free UeRadioCapability */
|
2020-05-25 16:15:22 +00:00
|
|
|
OGS_ASN_CLEAR_DATA(&mme_ue->ueRadioCapability);
|
2017-08-08 19:01:08 +00:00
|
|
|
|
2017-09-13 02:57:17 +00:00
|
|
|
/* Clear Transparent Container */
|
2020-05-25 16:15:22 +00:00
|
|
|
OGS_ASN_CLEAR_DATA(&mme_ue->container);
|
2017-09-13 02:57:17 +00:00
|
|
|
|
2018-01-29 07:47:07 +00:00
|
|
|
/* Delete All Timers */
|
2019-07-20 12:28:36 +00:00
|
|
|
CLEAR_MME_UE_ALL_TIMERS(mme_ue);
|
2019-07-20 11:38:03 +00:00
|
|
|
ogs_timer_delete(mme_ue->t3413.timer);
|
|
|
|
|
ogs_timer_delete(mme_ue->t3422.timer);
|
|
|
|
|
ogs_timer_delete(mme_ue->t3450.timer);
|
|
|
|
|
ogs_timer_delete(mme_ue->t3460.timer);
|
|
|
|
|
ogs_timer_delete(mme_ue->t3470.timer);
|
2023-01-26 12:22:17 +00:00
|
|
|
ogs_timer_delete(mme_ue->t_mobile_reachable.timer);
|
|
|
|
|
ogs_timer_delete(mme_ue->t_implicit_detach.timer);
|
2023-12-11 16:18:11 +00:00
|
|
|
ogs_timer_delete(mme_ue->gn.t_gn_holding);
|
2018-01-29 07:47:07 +00:00
|
|
|
|
2022-04-29 12:28:16 +00:00
|
|
|
enb_ue_unlink(mme_ue);
|
2018-01-29 10:10:54 +00:00
|
|
|
|
2017-04-28 07:11:45 +00:00
|
|
|
mme_sess_remove_all(mme_ue);
|
2021-03-08 12:25:09 +00:00
|
|
|
mme_session_remove_all(mme_ue);
|
2017-04-28 04:43:42 +00:00
|
|
|
|
2020-09-02 03:04:35 +00:00
|
|
|
mme_ebi_pool_final(mme_ue);
|
2020-08-29 14:53:02 +00:00
|
|
|
|
2023-04-09 01:34:19 +00:00
|
|
|
ogs_pool_free(&mme_s11_teid_pool, mme_ue->mme_s11_teid_node);
|
2023-12-20 18:15:47 +00:00
|
|
|
ogs_pool_free(&mme_gn_teid_pool, mme_ue->gn.mme_gn_teid_node);
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_pool_free(&mme_ue_pool, mme_ue);
|
2020-09-05 03:36:51 +00:00
|
|
|
|
|
|
|
|
ogs_info("[Removed] Number of MME-UEs is now %d",
|
|
|
|
|
ogs_list_count(&self.mme_ue_list));
|
2017-03-05 04:03:11 +00:00
|
|
|
}
|
|
|
|
|
|
2020-09-21 18:37:17 +00:00
|
|
|
void mme_ue_remove_all(void)
|
2017-04-06 12:44:30 +00:00
|
|
|
{
|
2019-06-30 11:46:15 +00:00
|
|
|
mme_ue_t *mme_ue = NULL, *next = NULL;;
|
2017-04-06 12:44:30 +00:00
|
|
|
|
2021-01-05 04:24:22 +00:00
|
|
|
ogs_list_for_each_safe(&self.mme_ue_list, next, mme_ue) {
|
|
|
|
|
enb_ue_t *enb_ue = enb_ue_cycle(mme_ue->enb_ue);
|
|
|
|
|
|
|
|
|
|
if (enb_ue) enb_ue_remove(enb_ue);
|
|
|
|
|
|
2017-04-28 07:11:45 +00:00
|
|
|
mme_ue_remove(mme_ue);
|
2021-01-05 04:24:22 +00:00
|
|
|
}
|
2017-04-10 14:59:59 +00:00
|
|
|
}
|
|
|
|
|
|
2022-08-19 09:58:55 +00:00
|
|
|
mme_ue_t *mme_ue_cycle(mme_ue_t *mme_ue)
|
|
|
|
|
{
|
|
|
|
|
return ogs_pool_cycle(&mme_ue_pool, mme_ue);
|
|
|
|
|
}
|
|
|
|
|
|
2020-09-21 18:37:17 +00:00
|
|
|
void mme_ue_fsm_init(mme_ue_t *mme_ue)
|
|
|
|
|
{
|
|
|
|
|
mme_event_t e;
|
|
|
|
|
|
|
|
|
|
ogs_assert(mme_ue);
|
|
|
|
|
|
|
|
|
|
memset(&e, 0, sizeof(e));
|
|
|
|
|
e.mme_ue = mme_ue;
|
2022-08-12 05:03:53 +00:00
|
|
|
ogs_fsm_init(&mme_ue->sm, emm_state_initial, emm_state_final, &e);
|
2020-09-21 18:37:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void mme_ue_fsm_fini(mme_ue_t *mme_ue)
|
|
|
|
|
{
|
|
|
|
|
mme_event_t e;
|
|
|
|
|
|
|
|
|
|
ogs_assert(mme_ue);
|
|
|
|
|
|
|
|
|
|
memset(&e, 0, sizeof(e));
|
|
|
|
|
e.mme_ue = mme_ue;
|
|
|
|
|
ogs_fsm_fini(&mme_ue->sm, &e);
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
mme_ue_t *mme_ue_find_by_imsi_bcd(const char *imsi_bcd)
|
2017-07-23 07:26:40 +00:00
|
|
|
{
|
2019-09-13 12:07:47 +00:00
|
|
|
uint8_t imsi[OGS_MAX_IMSI_LEN];
|
2017-07-23 07:26:40 +00:00
|
|
|
int imsi_len = 0;
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(imsi_bcd);
|
2017-07-23 07:26:40 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_bcd_to_buffer(imsi_bcd, imsi, &imsi_len);
|
2017-07-23 07:26:40 +00:00
|
|
|
|
|
|
|
|
return mme_ue_find_by_imsi(imsi, imsi_len);
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
mme_ue_t *mme_ue_find_by_imsi(const uint8_t *imsi, int imsi_len)
|
2017-04-28 04:43:42 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(imsi && imsi_len);
|
2017-04-28 04:43:42 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
return (mme_ue_t *)ogs_hash_get(self.imsi_ue_hash, imsi, imsi_len);
|
2017-04-28 04:43:42 +00:00
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
mme_ue_t *mme_ue_find_by_guti(const ogs_nas_eps_guti_t *guti)
|
2017-04-28 04:43:42 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(guti);
|
2017-04-28 04:43:42 +00:00
|
|
|
|
2019-05-26 06:27:09 +00:00
|
|
|
return (mme_ue_t *)ogs_hash_get(
|
2020-05-25 16:15:22 +00:00
|
|
|
self.guti_ue_hash, guti, sizeof(ogs_nas_eps_guti_t));
|
2017-04-28 04:43:42 +00:00
|
|
|
}
|
|
|
|
|
|
2023-12-20 18:15:47 +00:00
|
|
|
mme_ue_t *mme_ue_find_by_s11_local_teid(uint32_t teid)
|
2022-05-12 13:52:36 +00:00
|
|
|
{
|
2023-04-09 01:34:19 +00:00
|
|
|
return ogs_hash_get(self.mme_s11_teid_hash, &teid, sizeof(teid));
|
2022-05-12 13:52:36 +00:00
|
|
|
}
|
|
|
|
|
|
2023-12-20 18:15:47 +00:00
|
|
|
mme_ue_t *mme_ue_find_by_gn_local_teid(uint32_t teid)
|
|
|
|
|
{
|
|
|
|
|
return ogs_hash_get(self.mme_gn_teid_hash, &teid, sizeof(teid));
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
mme_ue_t *mme_ue_find_by_message(const ogs_nas_eps_message_t *message)
|
2017-07-28 05:06:40 +00:00
|
|
|
{
|
|
|
|
|
mme_ue_t *mme_ue = NULL;
|
2024-01-05 18:25:53 +00:00
|
|
|
const ogs_nas_eps_attach_request_t *attach_request = NULL;
|
|
|
|
|
const ogs_nas_eps_detach_request_from_ue_t *detach_request = NULL;
|
|
|
|
|
const ogs_nas_eps_tracking_area_update_request_t *tau_request = NULL;
|
|
|
|
|
const ogs_nas_eps_extended_service_request_t *extended_service_request = NULL;
|
|
|
|
|
const ogs_nas_eps_mobile_identity_t *eps_mobile_identity = NULL;
|
|
|
|
|
const ogs_nas_mobile_identity_t *mobile_identity = NULL;
|
2019-09-13 12:07:47 +00:00
|
|
|
|
|
|
|
|
char imsi_bcd[OGS_MAX_IMSI_BCD_LEN+1];
|
2024-01-05 18:25:53 +00:00
|
|
|
const ogs_nas_eps_mobile_identity_guti_t *eps_mobile_identity_guti = NULL;
|
|
|
|
|
const ogs_nas_mobile_identity_tmsi_t *mobile_identity_tmsi = NULL;
|
|
|
|
|
const served_gummei_t *served_gummei = NULL;
|
2020-05-25 16:15:22 +00:00
|
|
|
ogs_nas_eps_guti_t ogs_nas_guti;
|
2017-07-28 05:06:40 +00:00
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
switch (message->emm.h.message_type) {
|
2020-05-23 02:24:48 +00:00
|
|
|
case OGS_NAS_EPS_ATTACH_REQUEST:
|
2019-07-06 13:16:13 +00:00
|
|
|
attach_request = &message->emm.attach_request;
|
|
|
|
|
eps_mobile_identity = &attach_request->eps_mobile_identity;
|
2017-07-28 05:06:40 +00:00
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
switch(eps_mobile_identity->imsi.type) {
|
2019-09-13 12:07:47 +00:00
|
|
|
case OGS_NAS_EPS_MOBILE_IDENTITY_IMSI:
|
2023-09-16 13:27:21 +00:00
|
|
|
if (sizeof(ogs_nas_mobile_identity_imsi_t) !=
|
|
|
|
|
eps_mobile_identity->length) {
|
|
|
|
|
ogs_error("mobile_identity length (%d != %d)",
|
|
|
|
|
(int)sizeof(ogs_nas_mobile_identity_imsi_t),
|
|
|
|
|
eps_mobile_identity->length);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2020-06-04 18:12:05 +00:00
|
|
|
ogs_nas_eps_imsi_to_bcd(
|
2019-05-29 12:27:22 +00:00
|
|
|
&eps_mobile_identity->imsi, eps_mobile_identity->length,
|
|
|
|
|
imsi_bcd);
|
2017-07-28 05:06:40 +00:00
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
mme_ue = mme_ue_find_by_imsi_bcd(imsi_bcd);
|
|
|
|
|
if (mme_ue) {
|
2020-10-09 02:54:13 +00:00
|
|
|
ogs_info("[%s] known UE by IMSI", imsi_bcd);
|
2019-05-29 12:27:22 +00:00
|
|
|
} else {
|
2020-10-09 02:54:13 +00:00
|
|
|
ogs_info("[%s] Unknown UE by IMSI", imsi_bcd);
|
2017-07-28 05:06:40 +00:00
|
|
|
}
|
|
|
|
|
break;
|
2019-09-13 12:07:47 +00:00
|
|
|
case OGS_NAS_EPS_MOBILE_IDENTITY_GUTI:
|
2019-07-06 13:16:13 +00:00
|
|
|
eps_mobile_identity_guti = &eps_mobile_identity->guti;
|
2019-05-29 12:27:22 +00:00
|
|
|
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_nas_guti.nas_plmn_id = eps_mobile_identity_guti->nas_plmn_id;
|
|
|
|
|
ogs_nas_guti.mme_gid = eps_mobile_identity_guti->mme_gid;
|
|
|
|
|
ogs_nas_guti.mme_code = eps_mobile_identity_guti->mme_code;
|
|
|
|
|
ogs_nas_guti.m_tmsi = eps_mobile_identity_guti->m_tmsi;
|
2019-05-29 12:27:22 +00:00
|
|
|
|
2019-09-13 12:07:47 +00:00
|
|
|
mme_ue = mme_ue_find_by_guti(&ogs_nas_guti);
|
2019-05-29 12:27:22 +00:00
|
|
|
if (mme_ue) {
|
2020-10-09 02:54:13 +00:00
|
|
|
ogs_info("[%s] Known UE by GUTI[G:%d,C:%d,M_TMSI:0x%x]",
|
|
|
|
|
mme_ue->imsi_bcd,
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_nas_guti.mme_gid,
|
|
|
|
|
ogs_nas_guti.mme_code,
|
|
|
|
|
ogs_nas_guti.m_tmsi);
|
2019-05-29 12:27:22 +00:00
|
|
|
} else {
|
2020-09-11 01:50:20 +00:00
|
|
|
ogs_info("Unknown UE by GUTI[G:%d,C:%d,M_TMSI:0x%x]",
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_nas_guti.mme_gid,
|
|
|
|
|
ogs_nas_guti.mme_code,
|
|
|
|
|
ogs_nas_guti.m_tmsi);
|
2019-05-29 12:27:22 +00:00
|
|
|
}
|
2017-07-28 05:06:40 +00:00
|
|
|
break;
|
2019-05-29 12:27:22 +00:00
|
|
|
default:
|
2021-03-31 06:35:59 +00:00
|
|
|
ogs_error("Unknown EPS Mobile Identity Type [%d]",
|
|
|
|
|
eps_mobile_identity->imsi.type);
|
2019-05-29 12:27:22 +00:00
|
|
|
}
|
|
|
|
|
break;
|
2020-05-23 02:24:48 +00:00
|
|
|
case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST:
|
2019-07-06 13:16:13 +00:00
|
|
|
tau_request = &message->emm.tracking_area_update_request;
|
|
|
|
|
eps_mobile_identity = &tau_request->old_guti;
|
2019-05-29 12:27:22 +00:00
|
|
|
|
|
|
|
|
switch(eps_mobile_identity->imsi.type) {
|
2019-09-13 12:07:47 +00:00
|
|
|
case OGS_NAS_EPS_MOBILE_IDENTITY_GUTI:
|
2019-07-06 13:16:13 +00:00
|
|
|
eps_mobile_identity_guti = &eps_mobile_identity->guti;
|
2019-05-29 12:27:22 +00:00
|
|
|
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_nas_guti.nas_plmn_id = eps_mobile_identity_guti->nas_plmn_id;
|
|
|
|
|
ogs_nas_guti.mme_gid = eps_mobile_identity_guti->mme_gid;
|
|
|
|
|
ogs_nas_guti.mme_code = eps_mobile_identity_guti->mme_code;
|
|
|
|
|
ogs_nas_guti.m_tmsi = eps_mobile_identity_guti->m_tmsi;
|
2019-05-29 12:27:22 +00:00
|
|
|
|
2019-09-13 12:07:47 +00:00
|
|
|
mme_ue = mme_ue_find_by_guti(&ogs_nas_guti);
|
2019-05-29 12:27:22 +00:00
|
|
|
if (mme_ue) {
|
2020-10-09 02:54:13 +00:00
|
|
|
ogs_info("[%s] Known UE by GUTI[G:%d,C:%d,M_TMSI:0x%x]",
|
|
|
|
|
mme_ue->imsi_bcd,
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_nas_guti.mme_gid,
|
|
|
|
|
ogs_nas_guti.mme_code,
|
|
|
|
|
ogs_nas_guti.m_tmsi);
|
2019-05-29 12:27:22 +00:00
|
|
|
} else {
|
2020-09-09 02:16:46 +00:00
|
|
|
ogs_info("Unknown UE by GUTI[G:%d,C:%d,M_TMSI:0x%x]",
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_nas_guti.mme_gid,
|
|
|
|
|
ogs_nas_guti.mme_code,
|
|
|
|
|
ogs_nas_guti.m_tmsi);
|
2017-08-23 23:53:44 +00:00
|
|
|
}
|
2017-07-28 05:06:40 +00:00
|
|
|
break;
|
2019-07-06 13:16:13 +00:00
|
|
|
default:
|
2021-03-31 06:35:59 +00:00
|
|
|
ogs_error("Unknown EPS Mobile Identity Type [%d]",
|
|
|
|
|
eps_mobile_identity->imsi.type);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case OGS_NAS_EPS_DETACH_REQUEST:
|
|
|
|
|
detach_request = &message->emm.detach_request_from_ue;
|
|
|
|
|
eps_mobile_identity = &detach_request->eps_mobile_identity;
|
|
|
|
|
|
|
|
|
|
switch(eps_mobile_identity->imsi.type) {
|
|
|
|
|
case OGS_NAS_EPS_MOBILE_IDENTITY_GUTI:
|
|
|
|
|
eps_mobile_identity_guti = &eps_mobile_identity->guti;
|
|
|
|
|
|
|
|
|
|
ogs_nas_guti.nas_plmn_id = eps_mobile_identity_guti->nas_plmn_id;
|
|
|
|
|
ogs_nas_guti.mme_gid = eps_mobile_identity_guti->mme_gid;
|
|
|
|
|
ogs_nas_guti.mme_code = eps_mobile_identity_guti->mme_code;
|
|
|
|
|
ogs_nas_guti.m_tmsi = eps_mobile_identity_guti->m_tmsi;
|
|
|
|
|
|
|
|
|
|
mme_ue = mme_ue_find_by_guti(&ogs_nas_guti);
|
|
|
|
|
if (mme_ue) {
|
|
|
|
|
ogs_info("[%s] Known UE by GUTI[G:%d,C:%d,M_TMSI:0x%x]",
|
|
|
|
|
mme_ue->imsi_bcd,
|
|
|
|
|
ogs_nas_guti.mme_gid,
|
|
|
|
|
ogs_nas_guti.mme_code,
|
|
|
|
|
ogs_nas_guti.m_tmsi);
|
|
|
|
|
} else {
|
|
|
|
|
ogs_info("Unknown UE by GUTI[G:%d,C:%d,M_TMSI:0x%x]",
|
|
|
|
|
ogs_nas_guti.mme_gid,
|
|
|
|
|
ogs_nas_guti.mme_code,
|
|
|
|
|
ogs_nas_guti.m_tmsi);
|
|
|
|
|
}
|
2019-07-06 13:16:13 +00:00
|
|
|
break;
|
2021-03-31 06:35:59 +00:00
|
|
|
default:
|
|
|
|
|
ogs_error("Unknown EPS Mobile Identity Type [%d]",
|
|
|
|
|
eps_mobile_identity->imsi.type);
|
2017-07-28 05:06:40 +00:00
|
|
|
}
|
2019-07-06 13:16:13 +00:00
|
|
|
break;
|
2020-05-23 02:24:48 +00:00
|
|
|
case OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST:
|
2019-07-06 13:16:13 +00:00
|
|
|
extended_service_request = &message->emm.extended_service_request;
|
|
|
|
|
mobile_identity = &extended_service_request->m_tmsi;
|
|
|
|
|
|
|
|
|
|
switch(mobile_identity->tmsi.type) {
|
2019-09-13 12:07:47 +00:00
|
|
|
case OGS_NAS_MOBILE_IDENTITY_TMSI:
|
2019-07-06 13:16:13 +00:00
|
|
|
mobile_identity_tmsi = &mobile_identity->tmsi;
|
|
|
|
|
served_gummei = &mme_self()->served_gummei[0];
|
|
|
|
|
|
|
|
|
|
/* Use the first configured plmn_id and mme group id */
|
2020-04-27 02:18:47 +00:00
|
|
|
ogs_nas_from_plmn_id(
|
|
|
|
|
&ogs_nas_guti.nas_plmn_id, &served_gummei->plmn_id[0]);
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_nas_guti.mme_gid = served_gummei->mme_gid[0];
|
|
|
|
|
ogs_nas_guti.mme_code = served_gummei->mme_code[0];
|
|
|
|
|
ogs_nas_guti.m_tmsi = mobile_identity_tmsi->tmsi;
|
2019-07-06 13:16:13 +00:00
|
|
|
|
2019-09-13 12:07:47 +00:00
|
|
|
mme_ue = mme_ue_find_by_guti(&ogs_nas_guti);
|
2019-07-06 13:16:13 +00:00
|
|
|
if (mme_ue) {
|
2020-10-09 02:54:13 +00:00
|
|
|
ogs_info("[%s] Known UE by GUTI[G:%d,C:%d,M_TMSI:0x%x]",
|
|
|
|
|
mme_ue->imsi_bcd,
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_nas_guti.mme_gid,
|
|
|
|
|
ogs_nas_guti.mme_code,
|
|
|
|
|
ogs_nas_guti.m_tmsi);
|
2019-07-06 13:16:13 +00:00
|
|
|
} else {
|
2020-10-09 02:54:13 +00:00
|
|
|
ogs_info("Unknown UE by GUTI[G:%d,C:%d,M_TMSI:0x%x]",
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_nas_guti.mme_gid,
|
|
|
|
|
ogs_nas_guti.mme_code,
|
|
|
|
|
ogs_nas_guti.m_tmsi);
|
2019-07-06 13:16:13 +00:00
|
|
|
}
|
|
|
|
|
break;
|
2017-07-28 05:06:40 +00:00
|
|
|
default:
|
2021-03-31 06:35:59 +00:00
|
|
|
ogs_error("Unknown Mobile Identity Type [%d]",
|
|
|
|
|
mobile_identity->tmsi.type);
|
2017-07-28 05:06:40 +00:00
|
|
|
}
|
2019-05-29 12:27:22 +00:00
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
break;
|
2017-07-28 05:06:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return mme_ue;
|
|
|
|
|
}
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
int mme_ue_set_imsi(mme_ue_t *mme_ue, char *imsi_bcd)
|
2017-07-23 07:26:40 +00:00
|
|
|
{
|
2019-11-05 14:15:57 +00:00
|
|
|
mme_ue_t *old_mme_ue = NULL;
|
2023-02-20 11:49:48 +00:00
|
|
|
mme_sess_t *old_sess = NULL;
|
|
|
|
|
mme_bearer_t *old_bearer = NULL;
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(mme_ue && imsi_bcd);
|
2017-07-23 07:26:40 +00:00
|
|
|
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_cpystrn(mme_ue->imsi_bcd, imsi_bcd, OGS_MAX_IMSI_BCD_LEN+1);
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_bcd_to_buffer(mme_ue->imsi_bcd, mme_ue->imsi, &mme_ue->imsi_len);
|
2017-07-23 07:26:40 +00:00
|
|
|
|
2019-11-06 01:22:34 +00:00
|
|
|
/* Check if OLD mme_ue_t is existed */
|
2019-11-05 14:15:57 +00:00
|
|
|
old_mme_ue = mme_ue_find_by_imsi(mme_ue->imsi, mme_ue->imsi_len);
|
|
|
|
|
if (old_mme_ue) {
|
2019-11-06 01:22:34 +00:00
|
|
|
/* Check if OLD mme_ue_t is different with NEW mme_ue_t */
|
|
|
|
|
if (ogs_pool_index(&mme_ue_pool, mme_ue) !=
|
|
|
|
|
ogs_pool_index(&mme_ue_pool, old_mme_ue)) {
|
2020-10-09 02:54:13 +00:00
|
|
|
ogs_warn("[%s] OLD UE Context Release", mme_ue->imsi_bcd);
|
|
|
|
|
if (ECM_CONNECTED(old_mme_ue)) {
|
|
|
|
|
/* Implcit S1 release */
|
2023-12-13 08:54:37 +00:00
|
|
|
ogs_warn("[%s] Implicit S1 release", mme_ue->imsi_bcd);
|
|
|
|
|
ogs_warn("[%s] ENB_UE_S1AP_ID[%d] MME_UE_S1AP_ID[%d]",
|
2020-10-09 02:54:13 +00:00
|
|
|
old_mme_ue->imsi_bcd,
|
|
|
|
|
old_mme_ue->enb_ue->enb_ue_s1ap_id,
|
|
|
|
|
old_mme_ue->enb_ue->mme_ue_s1ap_id);
|
|
|
|
|
enb_ue_remove(old_mme_ue->enb_ue);
|
|
|
|
|
}
|
2022-01-31 13:58:52 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We should delete the MME-Session Context in the MME-UE Context.
|
2023-02-20 11:49:48 +00:00
|
|
|
* Otherwise, all unnecessary SESSIONs remain in SMF/UPF.
|
|
|
|
|
*
|
|
|
|
|
* In order to do this, MME-Session Context should be moved
|
|
|
|
|
* from OLD MME-UE Context to NEW MME-UE Context.
|
2022-01-31 13:58:52 +00:00
|
|
|
*
|
2023-02-20 11:49:48 +00:00
|
|
|
* If needed, The Session deletion process in NEW-MME UE context will work.
|
2022-01-31 13:58:52 +00:00
|
|
|
*
|
2023-02-20 11:49:48 +00:00
|
|
|
* Note that we should not send Session-Release to the SGW-C at this point.
|
|
|
|
|
* Another GTPv2-C Transaction can cause fatal errors.
|
2022-01-31 13:58:52 +00:00
|
|
|
*/
|
2023-02-20 11:49:48 +00:00
|
|
|
/* Phase-1 : Change MME-UE Context in Session Context */
|
|
|
|
|
ogs_list_for_each(&old_mme_ue->sess_list, old_sess) {
|
|
|
|
|
ogs_list_for_each(&old_sess->bearer_list, old_bearer) {
|
|
|
|
|
old_bearer->mme_ue = mme_ue;
|
|
|
|
|
|
|
|
|
|
if (old_bearer->ebi_node)
|
|
|
|
|
ogs_pool_free(
|
|
|
|
|
&old_mme_ue->ebi_pool, old_bearer->ebi_node);
|
|
|
|
|
old_bearer->ebi_node = NULL;
|
|
|
|
|
}
|
|
|
|
|
old_sess->mme_ue = mme_ue;
|
2022-01-31 13:58:52 +00:00
|
|
|
}
|
2023-02-20 11:49:48 +00:00
|
|
|
|
|
|
|
|
/* Phase-2 : Move Session Context from OLD to NEW MME-UE Context */
|
|
|
|
|
memcpy(&mme_ue->sess_list,
|
|
|
|
|
&old_mme_ue->sess_list, sizeof(mme_ue->sess_list));
|
|
|
|
|
|
|
|
|
|
/* Phase-3 : Clear Session Context in OLD MME-UE Context */
|
|
|
|
|
memset(&old_mme_ue->sess_list, 0, sizeof(old_mme_ue->sess_list));
|
|
|
|
|
|
|
|
|
|
/* Phase-4 : Move sgw_ue->sgw_s11_teid */
|
|
|
|
|
ogs_assert(old_mme_ue->sgw_ue);
|
|
|
|
|
ogs_assert(mme_ue->sgw_ue);
|
|
|
|
|
mme_ue->sgw_ue->sgw_s11_teid = old_mme_ue->sgw_ue->sgw_s11_teid;
|
|
|
|
|
|
[MME] Fixes crash in building s1ap message
Because a race condition can occur between S6A Diameter and S1AP message,
the following error handling code has been added.
1. InitialUEMessage + Attach Request + PDN Connectivity request
2. Authentication-Information-Request/Authentication-Information-Answer
3. Authentication Request/Response
4. Security-mode command/complete
5. Update-Location-Request/Update-Location-Answer
6. Detach request/accept
In the ULR/ULA process in step 6, the PDN Connectivity request is
pushed to the queue as an ESM_MESSAGE because the NAS-Type is still
an Attach Request.
See the code below in 'mme-s6a-handler.c' for where the queue is pushed.
if (mme_ue->nas_eps.type == MME_EPS_TYPE_ATTACH_REQUEST) {
rv = nas_eps_send_emm_to_esm(mme_ue,
&mme_ue->pdn_connectivity_request);
if (rv != OGS_OK) {
ogs_error("nas_eps_send_emm_to_esm() failed");
return OGS_NAS_EMM_CAUSE_PROTOCOL_ERROR_UNSPECIFIED;
}
} else if (mme_ue->nas_eps.type == MME_EPS_TYPE_TAU_REQUEST) {
r = nas_eps_send_tau_accept(mme_ue,
S1AP_ProcedureCode_id_InitialContextSetup);
ogs_expect(r == OGS_OK);
ogs_assert(r != OGS_ERROR);
} else {
ogs_error("Invalid Type[%d]", mme_ue->nas_eps.type);
return OGS_NAS_EMM_CAUSE_PROTOCOL_ERROR_UNSPECIFIED;
}
If you perform step 7 Detach request/accept here,
the NAS-Type becomes Detach Request and the EMM state changes
to emm_state_de_registered().
Since the PDN, which is an ESM message that was previously queued,
should not be processed in de_registered, the message is ignored
through error handling below.
Otherwise, MME will crash because there is no active bearer
in the initial_context_setup_request build process.
See the code below in 's1ap-build.c' for where the crash occurs.
ogs_list_for_each(&mme_ue->sess_list, sess) {
ogs_list_for_each(&sess->bearer_list, bearer) {
...
if (mme_ue->nas_eps.type == MME_EPS_TYPE_ATTACH_REQUEST) {
} else if (OGS_FSM_CHECK(&bearer->sm, esm_state_inactive)) {
ogs_warn("No active EPS bearer [%d]", bearer->ebi);
ogs_warn(" IMSI[%s] NAS-EPS Type[%d] "
"ENB_UE_S1AP_ID[%d] MME_UE_S1AP_ID[%d]",
mme_ue->imsi_bcd, mme_ue->nas_eps.type,
enb_ue->enb_ue_s1ap_id, enb_ue->mme_ue_s1ap_id);
continue;
}
...
}
}
2024-02-02 12:15:52 +00:00
|
|
|
MME_UE_CHECK(OGS_LOG_WARN, old_mme_ue);
|
2023-02-20 11:49:48 +00:00
|
|
|
mme_ue_remove(old_mme_ue);
|
2019-11-06 01:22:34 +00:00
|
|
|
}
|
2019-11-05 14:15:57 +00:00
|
|
|
}
|
|
|
|
|
|
2022-01-31 13:58:52 +00:00
|
|
|
if (mme_ue->imsi_len != 0)
|
|
|
|
|
ogs_hash_set(mme_self()->imsi_ue_hash,
|
|
|
|
|
mme_ue->imsi, mme_ue->imsi_len, NULL);
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_hash_set(self.imsi_ue_hash, mme_ue->imsi, mme_ue->imsi_len, mme_ue);
|
2017-07-23 07:26:40 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_OK;
|
2017-07-23 07:26:40 +00:00
|
|
|
}
|
|
|
|
|
|
2020-11-07 22:27:12 +00:00
|
|
|
bool mme_ue_have_indirect_tunnel(mme_ue_t *mme_ue)
|
2018-03-07 13:32:31 +00:00
|
|
|
{
|
|
|
|
|
mme_sess_t *sess = NULL;
|
2020-11-07 22:27:12 +00:00
|
|
|
mme_bearer_t *bearer = NULL;
|
2018-03-07 13:32:31 +00:00
|
|
|
|
2020-11-07 22:27:12 +00:00
|
|
|
ogs_assert(mme_ue);
|
|
|
|
|
|
|
|
|
|
ogs_list_for_each(&mme_ue->sess_list, sess) {
|
|
|
|
|
ogs_list_for_each(&sess->bearer_list, bearer) {
|
2018-03-07 13:32:31 +00:00
|
|
|
if (MME_HAVE_ENB_DL_INDIRECT_TUNNEL(bearer) ||
|
|
|
|
|
MME_HAVE_ENB_UL_INDIRECT_TUNNEL(bearer) ||
|
|
|
|
|
MME_HAVE_SGW_DL_INDIRECT_TUNNEL(bearer) ||
|
2019-05-29 12:27:22 +00:00
|
|
|
MME_HAVE_SGW_UL_INDIRECT_TUNNEL(bearer)) {
|
2020-11-07 22:27:12 +00:00
|
|
|
return true;
|
2018-03-07 13:32:31 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-11-07 22:27:12 +00:00
|
|
|
return false;
|
2018-03-07 13:32:31 +00:00
|
|
|
}
|
|
|
|
|
|
2020-11-07 22:27:12 +00:00
|
|
|
void mme_ue_clear_indirect_tunnel(mme_ue_t *mme_ue)
|
2018-03-07 13:32:31 +00:00
|
|
|
{
|
|
|
|
|
mme_sess_t *sess = NULL;
|
2020-11-07 22:27:12 +00:00
|
|
|
mme_bearer_t *bearer = NULL;
|
2018-03-07 13:32:31 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(mme_ue);
|
2018-03-07 13:32:31 +00:00
|
|
|
|
2020-11-07 22:27:12 +00:00
|
|
|
ogs_list_for_each(&mme_ue->sess_list, sess) {
|
|
|
|
|
ogs_list_for_each(&sess->bearer_list, bearer) {
|
2018-03-07 13:32:31 +00:00
|
|
|
CLEAR_INDIRECT_TUNNEL(bearer);
|
2020-11-07 22:27:12 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool mme_ue_have_active_eps_bearers(mme_ue_t *mme_ue)
|
|
|
|
|
{
|
|
|
|
|
mme_sess_t *sess = NULL;
|
2023-02-20 11:49:48 +00:00
|
|
|
|
|
|
|
|
ogs_assert(mme_ue);
|
|
|
|
|
|
|
|
|
|
ogs_list_for_each(&mme_ue->sess_list, sess) {
|
|
|
|
|
if (mme_sess_have_active_eps_bearers(sess) == true)
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool mme_sess_have_active_eps_bearers(mme_sess_t *sess)
|
|
|
|
|
{
|
2020-11-07 22:27:12 +00:00
|
|
|
mme_bearer_t *bearer = NULL;
|
2023-02-20 11:49:48 +00:00
|
|
|
ogs_assert(sess);
|
|
|
|
|
|
|
|
|
|
ogs_list_for_each(&sess->bearer_list, bearer) {
|
|
|
|
|
if (OGS_FSM_CHECK(&bearer->sm, esm_state_active))
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool mme_ue_have_session_release_pending(mme_ue_t *mme_ue)
|
|
|
|
|
{
|
|
|
|
|
mme_sess_t *sess = NULL;
|
2020-11-07 22:27:12 +00:00
|
|
|
|
|
|
|
|
ogs_assert(mme_ue);
|
2018-03-07 13:32:31 +00:00
|
|
|
|
2020-11-07 22:27:12 +00:00
|
|
|
ogs_list_for_each(&mme_ue->sess_list, sess) {
|
2023-02-20 11:49:48 +00:00
|
|
|
if (mme_sess_have_session_release_pending(sess) == true)
|
|
|
|
|
return true;
|
2018-03-07 13:32:31 +00:00
|
|
|
}
|
|
|
|
|
|
2020-11-07 22:27:12 +00:00
|
|
|
return false;
|
2018-03-07 13:32:31 +00:00
|
|
|
}
|
|
|
|
|
|
2023-02-20 11:49:48 +00:00
|
|
|
bool mme_sess_have_session_release_pending(mme_sess_t *sess)
|
|
|
|
|
{
|
|
|
|
|
mme_bearer_t *bearer = NULL;
|
|
|
|
|
ogs_assert(sess);
|
|
|
|
|
|
|
|
|
|
ogs_list_for_each(&sess->bearer_list, bearer) {
|
|
|
|
|
if (OGS_FSM_CHECK(&bearer->sm, esm_state_pdn_will_disconnect))
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int mme_ue_xact_count(mme_ue_t *mme_ue, uint8_t org)
|
|
|
|
|
{
|
|
|
|
|
sgw_ue_t *sgw_ue = NULL;
|
|
|
|
|
ogs_gtp_node_t *gnode = NULL;
|
|
|
|
|
|
|
|
|
|
ogs_assert(org == OGS_GTP_LOCAL_ORIGINATOR ||
|
|
|
|
|
org == OGS_GTP_REMOTE_ORIGINATOR);
|
|
|
|
|
|
|
|
|
|
sgw_ue = mme_ue->sgw_ue;
|
|
|
|
|
if (!sgw_ue) return 0;
|
|
|
|
|
|
|
|
|
|
gnode = sgw_ue->gnode;
|
|
|
|
|
if (!gnode) return 0;
|
|
|
|
|
|
|
|
|
|
return org == OGS_GTP_LOCAL_ORIGINATOR ?
|
|
|
|
|
ogs_list_count(&gnode->local_list) :
|
|
|
|
|
ogs_list_count(&gnode->remote_list);
|
|
|
|
|
}
|
|
|
|
|
|
2022-04-29 12:28:16 +00:00
|
|
|
void enb_ue_associate_mme_ue(enb_ue_t *enb_ue, mme_ue_t *mme_ue)
|
2017-07-27 12:50:55 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(mme_ue);
|
|
|
|
|
ogs_assert(enb_ue);
|
2017-07-27 12:50:55 +00:00
|
|
|
|
|
|
|
|
mme_ue->enb_ue = enb_ue;
|
|
|
|
|
enb_ue->mme_ue = mme_ue;
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-30 11:46:15 +00:00
|
|
|
void enb_ue_deassociate(enb_ue_t *enb_ue)
|
2017-09-12 14:07:55 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(enb_ue);
|
2017-09-18 12:30:04 +00:00
|
|
|
enb_ue->mme_ue = NULL;
|
2018-01-29 10:10:54 +00:00
|
|
|
}
|
2017-09-12 14:07:55 +00:00
|
|
|
|
2022-04-29 12:28:16 +00:00
|
|
|
void enb_ue_unlink(mme_ue_t *mme_ue)
|
2018-01-29 10:10:54 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(mme_ue);
|
2018-01-29 10:10:54 +00:00
|
|
|
mme_ue->enb_ue = NULL;
|
2017-09-12 14:07:55 +00:00
|
|
|
}
|
|
|
|
|
|
2022-04-29 12:28:16 +00:00
|
|
|
void enb_ue_source_associate_target(enb_ue_t *source_ue, enb_ue_t *target_ue)
|
2017-09-15 04:28:07 +00:00
|
|
|
{
|
2017-09-18 12:30:04 +00:00
|
|
|
mme_ue_t *mme_ue = NULL;
|
2017-09-15 04:28:07 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(source_ue);
|
|
|
|
|
ogs_assert(target_ue);
|
2017-09-18 12:30:04 +00:00
|
|
|
mme_ue = source_ue->mme_ue;
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(mme_ue);
|
2017-09-15 04:28:07 +00:00
|
|
|
|
2017-09-18 12:30:04 +00:00
|
|
|
target_ue->mme_ue = mme_ue;
|
|
|
|
|
target_ue->source_ue = source_ue;
|
|
|
|
|
source_ue->target_ue = target_ue;
|
2017-09-15 04:28:07 +00:00
|
|
|
}
|
|
|
|
|
|
2022-04-29 12:28:16 +00:00
|
|
|
void enb_ue_source_deassociate_target(enb_ue_t *enb_ue)
|
2017-09-15 03:54:26 +00:00
|
|
|
{
|
2017-09-18 12:30:04 +00:00
|
|
|
enb_ue_t *source_ue = NULL;
|
2017-09-15 04:28:07 +00:00
|
|
|
enb_ue_t *target_ue = NULL;
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(enb_ue);
|
2017-09-15 03:54:26 +00:00
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
if (enb_ue->target_ue) {
|
2017-09-18 12:30:04 +00:00
|
|
|
source_ue = enb_ue;
|
|
|
|
|
target_ue = enb_ue->target_ue;
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(source_ue->target_ue);
|
|
|
|
|
ogs_assert(target_ue->source_ue);
|
2017-09-18 12:30:04 +00:00
|
|
|
source_ue->target_ue = NULL;
|
|
|
|
|
target_ue->source_ue = NULL;
|
2019-05-29 12:27:22 +00:00
|
|
|
} else if (enb_ue->source_ue) {
|
2017-09-18 12:30:04 +00:00
|
|
|
target_ue = enb_ue;
|
|
|
|
|
source_ue = enb_ue->source_ue;
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(source_ue->target_ue);
|
|
|
|
|
ogs_assert(target_ue->source_ue);
|
2017-09-18 12:30:04 +00:00
|
|
|
source_ue->target_ue = NULL;
|
2017-09-15 03:54:26 +00:00
|
|
|
target_ue->source_ue = NULL;
|
2017-09-18 12:30:04 +00:00
|
|
|
}
|
2017-09-15 03:54:26 +00:00
|
|
|
}
|
|
|
|
|
|
2022-04-29 12:28:16 +00:00
|
|
|
void sgw_ue_associate_mme_ue(sgw_ue_t *sgw_ue, mme_ue_t *mme_ue)
|
|
|
|
|
{
|
|
|
|
|
ogs_assert(mme_ue);
|
|
|
|
|
ogs_assert(sgw_ue);
|
|
|
|
|
|
|
|
|
|
mme_ue->sgw_ue = sgw_ue;
|
|
|
|
|
sgw_ue->mme_ue = mme_ue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void sgw_ue_deassociate(sgw_ue_t *sgw_ue)
|
|
|
|
|
{
|
|
|
|
|
ogs_assert(sgw_ue);
|
|
|
|
|
sgw_ue->mme_ue = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void sgw_ue_unlink(mme_ue_t *mme_ue)
|
|
|
|
|
{
|
|
|
|
|
ogs_assert(mme_ue);
|
|
|
|
|
mme_ue->sgw_ue = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void sgw_ue_source_associate_target(sgw_ue_t *source_ue, sgw_ue_t *target_ue)
|
|
|
|
|
{
|
|
|
|
|
mme_ue_t *mme_ue = NULL;
|
|
|
|
|
|
|
|
|
|
ogs_assert(source_ue);
|
|
|
|
|
ogs_assert(target_ue);
|
|
|
|
|
mme_ue = source_ue->mme_ue;
|
|
|
|
|
ogs_assert(mme_ue);
|
|
|
|
|
|
|
|
|
|
target_ue->mme_ue = mme_ue;
|
|
|
|
|
target_ue->source_ue = source_ue;
|
|
|
|
|
source_ue->target_ue = target_ue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void sgw_ue_source_deassociate_target(sgw_ue_t *sgw_ue)
|
|
|
|
|
{
|
|
|
|
|
sgw_ue_t *source_ue = NULL;
|
|
|
|
|
sgw_ue_t *target_ue = NULL;
|
|
|
|
|
ogs_assert(sgw_ue);
|
|
|
|
|
|
|
|
|
|
if (sgw_ue->target_ue) {
|
|
|
|
|
source_ue = sgw_ue;
|
|
|
|
|
target_ue = sgw_ue->target_ue;
|
|
|
|
|
|
|
|
|
|
ogs_assert(source_ue->target_ue);
|
|
|
|
|
ogs_assert(target_ue->source_ue);
|
|
|
|
|
source_ue->target_ue = NULL;
|
|
|
|
|
target_ue->source_ue = NULL;
|
|
|
|
|
} else if (sgw_ue->source_ue) {
|
|
|
|
|
target_ue = sgw_ue;
|
|
|
|
|
source_ue = sgw_ue->source_ue;
|
|
|
|
|
|
|
|
|
|
ogs_assert(source_ue->target_ue);
|
|
|
|
|
ogs_assert(target_ue->source_ue);
|
|
|
|
|
source_ue->target_ue = NULL;
|
|
|
|
|
target_ue->source_ue = NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
mme_sess_t *mme_sess_add(mme_ue_t *mme_ue, uint8_t pti)
|
2017-04-08 01:18:48 +00:00
|
|
|
{
|
2017-04-27 14:06:10 +00:00
|
|
|
mme_sess_t *sess = NULL;
|
2017-04-13 10:15:53 +00:00
|
|
|
mme_bearer_t *bearer = NULL;
|
2017-04-08 01:18:48 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(mme_ue);
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_assert(pti != OGS_NAS_PROCEDURE_TRANSACTION_IDENTITY_UNASSIGNED);
|
2017-08-26 09:52:06 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_pool_alloc(&mme_sess_pool, &sess);
|
|
|
|
|
ogs_assert(sess);
|
2019-10-27 08:41:14 +00:00
|
|
|
memset(sess, 0, sizeof *sess);
|
2017-04-27 14:06:10 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_list_init(&sess->bearer_list);
|
2017-04-27 14:06:10 +00:00
|
|
|
|
2017-04-28 07:11:45 +00:00
|
|
|
sess->mme_ue = mme_ue;
|
2017-09-07 12:28:12 +00:00
|
|
|
sess->pti = pti;
|
2017-04-27 14:06:10 +00:00
|
|
|
|
2017-09-04 13:00:51 +00:00
|
|
|
bearer = mme_bearer_add(sess);
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(bearer);
|
2017-08-26 09:52:06 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_list_add(&mme_ue->sess_list, sess);
|
2017-11-09 05:56:03 +00:00
|
|
|
|
2019-11-05 06:23:33 +00:00
|
|
|
stats_add_mme_session();
|
|
|
|
|
|
2017-08-26 09:52:06 +00:00
|
|
|
return sess;
|
2017-04-27 14:06:10 +00:00
|
|
|
}
|
|
|
|
|
|
2019-06-30 11:46:15 +00:00
|
|
|
void mme_sess_remove(mme_sess_t *sess)
|
2017-04-27 14:06:10 +00:00
|
|
|
{
|
2020-09-05 03:36:51 +00:00
|
|
|
mme_ue_t *mme_ue = NULL;
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(sess);
|
2020-09-05 03:36:51 +00:00
|
|
|
mme_ue = sess->mme_ue;
|
|
|
|
|
ogs_assert(mme_ue);
|
2022-03-01 08:13:40 +00:00
|
|
|
|
2020-09-05 03:36:51 +00:00
|
|
|
ogs_list_remove(&mme_ue->sess_list, sess);
|
2017-04-27 14:06:10 +00:00
|
|
|
|
|
|
|
|
mme_bearer_remove_all(sess);
|
|
|
|
|
|
2019-09-13 12:07:47 +00:00
|
|
|
OGS_NAS_CLEAR_DATA(&sess->ue_pco);
|
2023-04-21 15:04:11 +00:00
|
|
|
OGS_NAS_CLEAR_DATA(&sess->ue_epco);
|
2019-09-13 12:07:47 +00:00
|
|
|
OGS_TLV_CLEAR_DATA(&sess->pgw_pco);
|
2023-04-21 15:04:11 +00:00
|
|
|
OGS_TLV_CLEAR_DATA(&sess->pgw_epco);
|
2017-09-06 11:29:55 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_pool_free(&mme_sess_pool, sess);
|
2019-11-05 06:23:33 +00:00
|
|
|
|
|
|
|
|
stats_remove_mme_session();
|
2017-04-27 14:06:10 +00:00
|
|
|
}
|
|
|
|
|
|
2019-06-30 11:46:15 +00:00
|
|
|
void mme_sess_remove_all(mme_ue_t *mme_ue)
|
2017-04-27 14:06:10 +00:00
|
|
|
{
|
|
|
|
|
mme_sess_t *sess = NULL, *next_sess = NULL;
|
2022-03-01 08:13:40 +00:00
|
|
|
|
2017-04-28 07:11:45 +00:00
|
|
|
sess = mme_sess_first(mme_ue);
|
2019-05-29 12:27:22 +00:00
|
|
|
while (sess) {
|
2017-04-27 14:06:10 +00:00
|
|
|
next_sess = mme_sess_next(sess);
|
|
|
|
|
|
|
|
|
|
mme_sess_remove(sess);
|
|
|
|
|
|
|
|
|
|
sess = next_sess;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
mme_sess_t *mme_sess_find_by_pti(const mme_ue_t *mme_ue, uint8_t pti)
|
2017-04-27 14:06:10 +00:00
|
|
|
{
|
2017-09-07 12:28:12 +00:00
|
|
|
mme_sess_t *sess = NULL;
|
2017-04-27 14:06:10 +00:00
|
|
|
|
2017-09-07 12:28:12 +00:00
|
|
|
sess = mme_sess_first(mme_ue);
|
2019-05-29 12:27:22 +00:00
|
|
|
while(sess) {
|
2017-09-07 12:28:12 +00:00
|
|
|
if (pti == sess->pti)
|
|
|
|
|
return sess;
|
|
|
|
|
|
|
|
|
|
sess = mme_sess_next(sess);
|
|
|
|
|
}
|
2017-08-26 09:52:06 +00:00
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
mme_sess_t *mme_sess_find_by_ebi(const mme_ue_t *mme_ue, uint8_t ebi)
|
2017-08-26 09:52:06 +00:00
|
|
|
{
|
2017-09-01 13:21:12 +00:00
|
|
|
mme_bearer_t *bearer = NULL;
|
2017-04-27 14:06:10 +00:00
|
|
|
|
2017-09-01 13:21:12 +00:00
|
|
|
bearer = mme_bearer_find_by_ue_ebi(mme_ue, ebi);
|
|
|
|
|
if (bearer)
|
|
|
|
|
return bearer->sess;
|
2017-04-27 14:06:10 +00:00
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
mme_sess_t *mme_sess_find_by_apn(const mme_ue_t *mme_ue, const char *apn)
|
2017-09-21 07:03:42 +00:00
|
|
|
{
|
|
|
|
|
mme_sess_t *sess = NULL;
|
|
|
|
|
|
|
|
|
|
sess = mme_sess_first(mme_ue);
|
2019-05-29 12:27:22 +00:00
|
|
|
while (sess) {
|
2024-01-05 17:32:20 +00:00
|
|
|
if (sess->session) {
|
|
|
|
|
ogs_assert(sess->session->name);
|
|
|
|
|
if (ogs_strcasecmp(sess->session->name, apn) == 0)
|
|
|
|
|
return sess;
|
|
|
|
|
}
|
2017-09-21 07:03:42 +00:00
|
|
|
sess = mme_sess_next(sess);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
mme_sess_t *mme_sess_first(const mme_ue_t *mme_ue)
|
2017-04-27 23:28:04 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
return ogs_list_first(&mme_ue->sess_list);
|
2017-04-27 23:28:04 +00:00
|
|
|
}
|
|
|
|
|
|
2019-06-30 11:29:25 +00:00
|
|
|
mme_sess_t *mme_sess_next(mme_sess_t *sess)
|
2017-04-27 23:28:04 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
return ogs_list_next(sess);
|
2017-04-27 23:28:04 +00:00
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
unsigned int mme_sess_count(const mme_ue_t *mme_ue)
|
2018-01-30 12:57:19 +00:00
|
|
|
{
|
|
|
|
|
unsigned int count = 0;
|
|
|
|
|
mme_sess_t *sess = NULL;
|
|
|
|
|
|
2023-02-20 11:49:48 +00:00
|
|
|
ogs_list_for_each(&mme_ue->sess_list, sess) {
|
2018-01-30 12:57:19 +00:00
|
|
|
count++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return count;
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-30 11:29:25 +00:00
|
|
|
mme_bearer_t *mme_bearer_add(mme_sess_t *sess)
|
2017-04-08 01:18:48 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
mme_event_t e;
|
2017-09-04 13:00:51 +00:00
|
|
|
|
2017-04-13 10:15:53 +00:00
|
|
|
mme_bearer_t *bearer = NULL;
|
2017-04-28 07:11:45 +00:00
|
|
|
mme_ue_t *mme_ue = NULL;
|
2017-04-08 01:18:48 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(sess);
|
2017-04-28 07:11:45 +00:00
|
|
|
mme_ue = sess->mme_ue;
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(mme_ue);
|
2017-04-08 01:18:48 +00:00
|
|
|
|
2020-08-30 03:27:54 +00:00
|
|
|
ogs_pool_alloc(&mme_bearer_pool, &bearer);
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(bearer);
|
2019-10-27 08:41:14 +00:00
|
|
|
memset(bearer, 0, sizeof *bearer);
|
2017-04-08 01:18:48 +00:00
|
|
|
|
2020-09-02 03:04:35 +00:00
|
|
|
ogs_pool_alloc(&mme_ue->ebi_pool, &bearer->ebi_node);
|
|
|
|
|
ogs_assert(bearer->ebi_node);
|
2020-08-30 03:27:54 +00:00
|
|
|
|
2020-09-02 03:04:35 +00:00
|
|
|
bearer->ebi = *(bearer->ebi_node);
|
|
|
|
|
|
|
|
|
|
ogs_assert(bearer->ebi >= MIN_EPS_BEARER_ID &&
|
|
|
|
|
bearer->ebi <= MAX_EPS_BEARER_ID);
|
2017-09-01 13:21:12 +00:00
|
|
|
|
2017-04-28 07:11:45 +00:00
|
|
|
bearer->mme_ue = mme_ue;
|
2017-04-27 14:06:10 +00:00
|
|
|
bearer->sess = sess;
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_list_add(&sess->bearer_list, bearer);
|
2019-07-20 14:06:54 +00:00
|
|
|
|
|
|
|
|
bearer->t3489.timer = ogs_timer_add(
|
2020-08-26 03:05:01 +00:00
|
|
|
ogs_app()->timer_mgr, mme_timer_t3489_expire, bearer);
|
2019-10-27 08:41:14 +00:00
|
|
|
bearer->t3489.pkbuf = NULL;
|
2022-03-01 08:13:40 +00:00
|
|
|
|
2020-06-22 03:07:14 +00:00
|
|
|
memset(&e, 0, sizeof(e));
|
2019-04-27 14:54:30 +00:00
|
|
|
e.bearer = bearer;
|
2022-08-12 05:03:53 +00:00
|
|
|
ogs_fsm_init(&bearer->sm, esm_state_initial, esm_state_final, &e);
|
2017-09-04 13:00:51 +00:00
|
|
|
|
2017-04-13 10:15:53 +00:00
|
|
|
return bearer;
|
2017-04-08 01:18:48 +00:00
|
|
|
}
|
|
|
|
|
|
2019-06-30 11:46:15 +00:00
|
|
|
void mme_bearer_remove(mme_bearer_t *bearer)
|
2017-04-08 01:18:48 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
mme_event_t e;
|
2017-09-04 13:00:51 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(bearer);
|
2020-08-29 14:53:02 +00:00
|
|
|
ogs_assert(bearer->mme_ue);
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(bearer->sess);
|
2017-09-04 13:00:51 +00:00
|
|
|
|
2020-06-22 03:07:14 +00:00
|
|
|
memset(&e, 0, sizeof(e));
|
2019-04-27 14:54:30 +00:00
|
|
|
e.bearer = bearer;
|
|
|
|
|
ogs_fsm_fini(&bearer->sm, &e);
|
2017-09-06 06:38:24 +00:00
|
|
|
|
2019-07-20 16:03:19 +00:00
|
|
|
CLEAR_BEARER_ALL_TIMERS(bearer);
|
2019-07-20 14:06:54 +00:00
|
|
|
ogs_timer_delete(bearer->t3489.timer);
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_list_remove(&bearer->sess->bearer_list, bearer);
|
2017-11-09 05:56:03 +00:00
|
|
|
|
2019-09-13 12:07:47 +00:00
|
|
|
OGS_TLV_CLEAR_DATA(&bearer->tft);
|
2020-08-29 14:53:02 +00:00
|
|
|
|
2023-02-20 11:49:48 +00:00
|
|
|
if (bearer->ebi_node)
|
|
|
|
|
ogs_pool_free(&bearer->mme_ue->ebi_pool, bearer->ebi_node);
|
2022-03-01 08:13:40 +00:00
|
|
|
|
2020-08-30 03:27:54 +00:00
|
|
|
ogs_pool_free(&mme_bearer_pool, bearer);
|
2017-04-08 01:18:48 +00:00
|
|
|
}
|
|
|
|
|
|
2019-06-30 11:46:15 +00:00
|
|
|
void mme_bearer_remove_all(mme_sess_t *sess)
|
2017-04-08 01:18:48 +00:00
|
|
|
{
|
2017-04-13 10:15:53 +00:00
|
|
|
mme_bearer_t *bearer = NULL, *next_bearer = NULL;
|
2017-04-08 01:18:48 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(sess);
|
2022-03-01 08:13:40 +00:00
|
|
|
|
2017-04-27 14:06:10 +00:00
|
|
|
bearer = mme_bearer_first(sess);
|
2019-05-29 12:27:22 +00:00
|
|
|
while (bearer) {
|
2017-04-13 10:15:53 +00:00
|
|
|
next_bearer = mme_bearer_next(bearer);
|
2017-04-08 01:18:48 +00:00
|
|
|
|
2017-04-13 10:15:53 +00:00
|
|
|
mme_bearer_remove(bearer);
|
2017-04-08 01:18:48 +00:00
|
|
|
|
2017-04-13 10:15:53 +00:00
|
|
|
bearer = next_bearer;
|
2017-04-08 01:18:48 +00:00
|
|
|
}
|
2017-04-10 14:59:59 +00:00
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
mme_bearer_t *mme_bearer_find_by_sess_ebi(const mme_sess_t *sess, uint8_t ebi)
|
2017-09-01 13:21:12 +00:00
|
|
|
{
|
|
|
|
|
mme_bearer_t *bearer = NULL;
|
|
|
|
|
|
2019-11-15 14:56:55 +00:00
|
|
|
ogs_assert(sess);
|
|
|
|
|
|
2017-09-01 13:21:12 +00:00
|
|
|
bearer = mme_bearer_first(sess);
|
2019-05-29 12:27:22 +00:00
|
|
|
while (bearer) {
|
2020-09-02 03:04:35 +00:00
|
|
|
if (ebi == bearer->ebi)
|
2017-09-01 13:21:12 +00:00
|
|
|
return bearer;
|
|
|
|
|
|
|
|
|
|
bearer = mme_bearer_next(bearer);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
mme_bearer_t *mme_bearer_find_by_ue_ebi(const mme_ue_t *mme_ue, uint8_t ebi)
|
2017-09-01 13:21:12 +00:00
|
|
|
{
|
|
|
|
|
mme_sess_t *sess = NULL;
|
|
|
|
|
mme_bearer_t *bearer = NULL;
|
2022-03-01 08:13:40 +00:00
|
|
|
|
2019-11-15 14:56:55 +00:00
|
|
|
ogs_assert(mme_ue);
|
|
|
|
|
|
2017-09-01 13:21:12 +00:00
|
|
|
sess = mme_sess_first(mme_ue);
|
2019-05-29 12:27:22 +00:00
|
|
|
while (sess) {
|
2017-09-01 13:21:12 +00:00
|
|
|
bearer = mme_bearer_find_by_sess_ebi(sess, ebi);
|
2019-05-29 12:27:22 +00:00
|
|
|
if (bearer) {
|
2017-09-01 13:21:12 +00:00
|
|
|
return bearer;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sess = mme_sess_next(sess);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-30 11:29:25 +00:00
|
|
|
mme_bearer_t *mme_bearer_find_or_add_by_message(
|
2022-04-14 08:34:55 +00:00
|
|
|
mme_ue_t *mme_ue, ogs_nas_eps_message_t *message, int create_action)
|
2017-09-21 07:03:42 +00:00
|
|
|
{
|
2023-01-23 01:37:22 +00:00
|
|
|
int r;
|
2019-09-13 12:07:47 +00:00
|
|
|
uint8_t pti = OGS_NAS_PROCEDURE_TRANSACTION_IDENTITY_UNASSIGNED;
|
|
|
|
|
uint8_t ebi = OGS_NAS_EPS_BEARER_IDENTITY_UNASSIGNED;
|
2017-09-21 07:03:42 +00:00
|
|
|
|
|
|
|
|
mme_bearer_t *bearer = NULL;
|
|
|
|
|
mme_sess_t *sess = NULL;
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(mme_ue);
|
|
|
|
|
ogs_assert(message);
|
2017-09-21 07:03:42 +00:00
|
|
|
|
|
|
|
|
pti = message->esm.h.procedure_transaction_identity;
|
|
|
|
|
ebi = message->esm.h.eps_bearer_identity;
|
|
|
|
|
|
2023-05-05 09:06:25 +00:00
|
|
|
ogs_debug("mme_bearer_find_or_add_by_message() : "
|
|
|
|
|
"ESM message type:%d, PTI:%d, EBI:%d",
|
|
|
|
|
message->esm.h.message_type, pti, ebi);
|
2018-01-13 12:19:43 +00:00
|
|
|
|
2019-09-13 12:07:47 +00:00
|
|
|
if (ebi != OGS_NAS_EPS_BEARER_IDENTITY_UNASSIGNED) {
|
2017-09-21 07:03:42 +00:00
|
|
|
bearer = mme_bearer_find_by_ue_ebi(mme_ue, ebi);
|
2019-12-28 12:46:30 +00:00
|
|
|
if (!bearer) {
|
|
|
|
|
ogs_error("No Bearer : EBI[%d]", ebi);
|
2023-01-23 01:37:22 +00:00
|
|
|
r = nas_eps_send_attach_reject(mme_ue,
|
2022-07-19 03:42:02 +00:00
|
|
|
OGS_NAS_EMM_CAUSE_PROTOCOL_ERROR_UNSPECIFIED,
|
2023-01-23 01:37:22 +00:00
|
|
|
OGS_NAS_ESM_CAUSE_PROTOCOL_ERROR_UNSPECIFIED);
|
|
|
|
|
ogs_expect(r == OGS_OK);
|
|
|
|
|
ogs_assert(r != OGS_ERROR);
|
2019-12-28 12:46:30 +00:00
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2017-09-21 07:03:42 +00:00
|
|
|
return bearer;
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-13 12:07:47 +00:00
|
|
|
if (pti == OGS_NAS_PROCEDURE_TRANSACTION_IDENTITY_UNASSIGNED) {
|
2019-07-21 03:20:26 +00:00
|
|
|
ogs_error("Both PTI[%d] and EBI[%d] are 0", pti, ebi);
|
2023-01-23 01:37:22 +00:00
|
|
|
r = nas_eps_send_attach_reject(mme_ue,
|
2022-07-19 03:42:02 +00:00
|
|
|
OGS_NAS_EMM_CAUSE_PROTOCOL_ERROR_UNSPECIFIED,
|
2023-01-23 01:37:22 +00:00
|
|
|
OGS_NAS_ESM_CAUSE_PROTOCOL_ERROR_UNSPECIFIED);
|
|
|
|
|
ogs_expect(r == OGS_OK);
|
|
|
|
|
ogs_assert(r != OGS_ERROR);
|
2019-07-21 03:20:26 +00:00
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-23 02:24:48 +00:00
|
|
|
if (message->esm.h.message_type == OGS_NAS_EPS_PDN_DISCONNECT_REQUEST) {
|
2022-03-01 08:13:40 +00:00
|
|
|
ogs_nas_eps_pdn_disconnect_request_t *pdn_disconnect_request =
|
2018-01-13 12:19:43 +00:00
|
|
|
&message->esm.pdn_disconnect_request;
|
2019-09-13 12:07:47 +00:00
|
|
|
ogs_nas_linked_eps_bearer_identity_t *linked_eps_bearer_identity =
|
2018-01-13 12:19:43 +00:00
|
|
|
&pdn_disconnect_request->linked_eps_bearer_identity;
|
|
|
|
|
|
|
|
|
|
bearer = mme_bearer_find_by_ue_ebi(mme_ue,
|
|
|
|
|
linked_eps_bearer_identity->eps_bearer_identity);
|
2019-12-28 12:46:30 +00:00
|
|
|
if (!bearer) {
|
2022-03-01 08:13:40 +00:00
|
|
|
ogs_error("No Bearer : Linked-EBI[%d]",
|
2019-12-28 12:46:30 +00:00
|
|
|
linked_eps_bearer_identity->eps_bearer_identity);
|
2023-01-23 01:37:22 +00:00
|
|
|
r = nas_eps_send_attach_reject(mme_ue,
|
2022-07-19 03:42:02 +00:00
|
|
|
OGS_NAS_EMM_CAUSE_PROTOCOL_ERROR_UNSPECIFIED,
|
2023-01-23 01:37:22 +00:00
|
|
|
OGS_NAS_ESM_CAUSE_PROTOCOL_ERROR_UNSPECIFIED);
|
|
|
|
|
ogs_expect(r == OGS_OK);
|
|
|
|
|
ogs_assert(r != OGS_ERROR);
|
2019-12-28 12:46:30 +00:00
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
} else if (message->esm.h.message_type ==
|
2020-05-23 02:24:48 +00:00
|
|
|
OGS_NAS_EPS_BEARER_RESOURCE_ALLOCATION_REQUEST) {
|
|
|
|
|
ogs_nas_eps_bearer_resource_allocation_request_t
|
2019-12-28 12:46:30 +00:00
|
|
|
*bearer_allocation_request =
|
|
|
|
|
&message->esm.bearer_resource_allocation_request;
|
|
|
|
|
ogs_nas_linked_eps_bearer_identity_t *linked_eps_bearer_identity =
|
|
|
|
|
&bearer_allocation_request->linked_eps_bearer_identity;
|
2019-12-19 13:14:13 +00:00
|
|
|
|
2019-12-28 12:46:30 +00:00
|
|
|
bearer = mme_bearer_find_by_ue_ebi(mme_ue,
|
|
|
|
|
linked_eps_bearer_identity->eps_bearer_identity);
|
|
|
|
|
if (!bearer) {
|
2022-03-01 08:13:40 +00:00
|
|
|
ogs_error("No Bearer : Linked-EBI[%d]",
|
2019-12-28 12:46:30 +00:00
|
|
|
linked_eps_bearer_identity->eps_bearer_identity);
|
2023-01-23 01:37:22 +00:00
|
|
|
r = nas_eps_send_bearer_resource_allocation_reject(
|
2022-07-19 03:42:02 +00:00
|
|
|
mme_ue, pti,
|
2023-01-23 01:37:22 +00:00
|
|
|
OGS_NAS_ESM_CAUSE_INVALID_EPS_BEARER_IDENTITY);
|
|
|
|
|
ogs_expect(r == OGS_OK);
|
|
|
|
|
ogs_assert(r != OGS_ERROR);
|
2019-12-28 12:46:30 +00:00
|
|
|
return NULL;
|
|
|
|
|
}
|
2021-01-11 04:36:12 +00:00
|
|
|
|
2019-12-19 13:24:26 +00:00
|
|
|
} else if (message->esm.h.message_type ==
|
2020-05-23 02:24:48 +00:00
|
|
|
OGS_NAS_EPS_BEARER_RESOURCE_MODIFICATION_REQUEST) {
|
|
|
|
|
ogs_nas_eps_bearer_resource_modification_request_t
|
2019-12-28 12:46:30 +00:00
|
|
|
*bearer_modification_request =
|
|
|
|
|
&message->esm.bearer_resource_modification_request;
|
2019-12-19 13:14:13 +00:00
|
|
|
ogs_nas_linked_eps_bearer_identity_t *linked_eps_bearer_identity =
|
|
|
|
|
&bearer_modification_request->eps_bearer_identity_for_packet_filter;
|
|
|
|
|
|
|
|
|
|
bearer = mme_bearer_find_by_ue_ebi(mme_ue,
|
|
|
|
|
linked_eps_bearer_identity->eps_bearer_identity);
|
2019-12-28 12:46:30 +00:00
|
|
|
if (!bearer) {
|
2021-01-11 04:36:12 +00:00
|
|
|
ogs_error("No Bearer : Linked-EBI[%d]",
|
2019-12-28 12:46:30 +00:00
|
|
|
linked_eps_bearer_identity->eps_bearer_identity);
|
2023-01-23 01:37:22 +00:00
|
|
|
r = nas_eps_send_bearer_resource_modification_reject(
|
2022-07-19 03:42:02 +00:00
|
|
|
mme_ue, pti,
|
2023-01-23 01:37:22 +00:00
|
|
|
OGS_NAS_ESM_CAUSE_INVALID_EPS_BEARER_IDENTITY);
|
|
|
|
|
ogs_expect(r == OGS_OK);
|
|
|
|
|
ogs_assert(r != OGS_ERROR);
|
2019-12-28 12:46:30 +00:00
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (bearer) {
|
2018-01-13 12:19:43 +00:00
|
|
|
sess = bearer->sess;
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(sess);
|
2018-01-13 12:19:43 +00:00
|
|
|
sess->pti = pti;
|
|
|
|
|
|
|
|
|
|
return bearer;
|
2019-12-28 12:46:30 +00:00
|
|
|
}
|
|
|
|
|
|
2020-05-23 02:24:48 +00:00
|
|
|
if (message->esm.h.message_type == OGS_NAS_EPS_PDN_CONNECTIVITY_REQUEST) {
|
|
|
|
|
ogs_nas_eps_pdn_connectivity_request_t *pdn_connectivity_request =
|
2019-12-28 12:46:30 +00:00
|
|
|
&message->esm.pdn_connectivity_request;
|
|
|
|
|
if (pdn_connectivity_request->presencemask &
|
2022-03-24 12:52:42 +00:00
|
|
|
OGS_NAS_EPS_PDN_CONNECTIVITY_REQUEST_ACCESS_POINT_NAME_PRESENT) {
|
2019-12-28 12:46:30 +00:00
|
|
|
sess = mme_sess_find_by_apn(mme_ue,
|
|
|
|
|
pdn_connectivity_request->access_point_name.apn);
|
2022-04-14 08:34:55 +00:00
|
|
|
if (sess && create_action != OGS_GTP_CREATE_IN_ATTACH_REQUEST) {
|
2023-01-23 01:37:22 +00:00
|
|
|
r = nas_eps_send_pdn_connectivity_reject(
|
2022-03-24 12:52:42 +00:00
|
|
|
sess,
|
2022-07-19 03:42:02 +00:00
|
|
|
OGS_NAS_ESM_CAUSE_MULTIPLE_PDN_CONNECTIONS_FOR_A_GIVEN_APN_NOT_ALLOWED,
|
2023-01-23 01:37:22 +00:00
|
|
|
create_action);
|
|
|
|
|
ogs_expect(r == OGS_OK);
|
|
|
|
|
ogs_assert(r != OGS_ERROR);
|
2022-03-24 12:52:42 +00:00
|
|
|
ogs_warn("APN duplicated [%s]",
|
|
|
|
|
pdn_connectivity_request->access_point_name.apn);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
2019-12-28 12:46:30 +00:00
|
|
|
sess = mme_sess_first(mme_ue);
|
2023-08-07 13:13:35 +00:00
|
|
|
ogs_debug("[%s:%p]", mme_ue->imsi_bcd, mme_ue);
|
|
|
|
|
if (sess) {
|
|
|
|
|
ogs_debug("[%s:%d:%d:%p]",
|
|
|
|
|
sess->session ? sess->session->name : "Unknown",
|
|
|
|
|
sess->pti, pti, sess);
|
|
|
|
|
ogs_debug("[%s:%p]",
|
|
|
|
|
sess->mme_ue ? sess->mme_ue->imsi_bcd : "Unknown",
|
|
|
|
|
sess->mme_ue);
|
|
|
|
|
}
|
2024-02-27 12:16:50 +00:00
|
|
|
MME_UE_CHECK(OGS_LOG_DEBUG, mme_ue);
|
2022-03-24 12:52:42 +00:00
|
|
|
}
|
2019-12-28 12:46:30 +00:00
|
|
|
|
2023-08-07 13:13:35 +00:00
|
|
|
if (!sess) {
|
2019-12-28 12:46:30 +00:00
|
|
|
sess = mme_sess_add(mme_ue, pti);
|
2023-08-07 13:13:35 +00:00
|
|
|
ogs_assert(sess);
|
|
|
|
|
|
|
|
|
|
ogs_debug("[%s:%p]", mme_ue->imsi_bcd, mme_ue);
|
|
|
|
|
ogs_debug("[%s:%d:%d:%p]",
|
|
|
|
|
sess->session ? sess->session->name : "Unknown",
|
|
|
|
|
sess->pti, pti, sess);
|
|
|
|
|
ogs_debug("[%s:%p]",
|
|
|
|
|
sess->mme_ue ? sess->mme_ue->imsi_bcd : "Unknown",
|
|
|
|
|
sess->mme_ue);
|
2024-02-27 12:16:50 +00:00
|
|
|
MME_UE_CHECK(OGS_LOG_DEBUG, mme_ue);
|
2023-08-07 13:13:35 +00:00
|
|
|
} else {
|
2019-12-28 12:46:30 +00:00
|
|
|
sess->pti = pti;
|
2023-08-07 13:13:35 +00:00
|
|
|
ogs_debug("[%s:%p]", mme_ue->imsi_bcd, mme_ue);
|
|
|
|
|
ogs_debug("[%s:%d:%d:%p]",
|
|
|
|
|
sess->session ? sess->session->name : "Unknown",
|
|
|
|
|
sess->pti, pti, sess);
|
|
|
|
|
ogs_debug("[%s:%p]",
|
|
|
|
|
sess->mme_ue ? sess->mme_ue->imsi_bcd : "Unknown",
|
|
|
|
|
sess->mme_ue);
|
2024-02-27 12:16:50 +00:00
|
|
|
MME_UE_CHECK(OGS_LOG_DEBUG, mme_ue);
|
2023-08-07 13:13:35 +00:00
|
|
|
}
|
2019-12-28 12:46:30 +00:00
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
} else {
|
2017-09-21 07:03:42 +00:00
|
|
|
sess = mme_sess_find_by_pti(mme_ue, pti);
|
2020-09-07 01:34:17 +00:00
|
|
|
if (!sess) {
|
|
|
|
|
ogs_error("No Session : ESM message type[%d], PTI[%d]",
|
|
|
|
|
message->esm.h.message_type, pti);
|
2023-01-23 01:37:22 +00:00
|
|
|
r = nas_eps_send_attach_reject(mme_ue,
|
2022-07-19 03:42:02 +00:00
|
|
|
OGS_NAS_EMM_CAUSE_PROTOCOL_ERROR_UNSPECIFIED,
|
2023-01-23 01:37:22 +00:00
|
|
|
OGS_NAS_ESM_CAUSE_PROTOCOL_ERROR_UNSPECIFIED);
|
|
|
|
|
ogs_expect(r == OGS_OK);
|
|
|
|
|
ogs_assert(r != OGS_ERROR);
|
2020-09-07 01:34:17 +00:00
|
|
|
return NULL;
|
|
|
|
|
}
|
2017-09-21 07:03:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bearer = mme_default_bearer_in_sess(sess);
|
2023-05-05 09:06:25 +00:00
|
|
|
if (!bearer) {
|
|
|
|
|
ogs_error("No Bearer(%d) : ESM message type:%d, PTI:%d, EBI:%d",
|
|
|
|
|
mme_sess_count(mme_ue), message->esm.h.message_type, pti, ebi);
|
|
|
|
|
ogs_assert_if_reached();
|
|
|
|
|
}
|
2019-12-28 12:46:30 +00:00
|
|
|
|
2017-09-21 07:03:42 +00:00
|
|
|
return bearer;
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-30 11:29:25 +00:00
|
|
|
mme_bearer_t *mme_default_bearer_in_sess(mme_sess_t *sess)
|
2017-04-08 01:18:48 +00:00
|
|
|
{
|
2019-11-15 14:56:55 +00:00
|
|
|
ogs_assert(sess);
|
2017-04-27 23:28:04 +00:00
|
|
|
return mme_bearer_first(sess);
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-30 11:29:25 +00:00
|
|
|
mme_bearer_t *mme_linked_bearer(mme_bearer_t *bearer)
|
2017-09-04 15:04:05 +00:00
|
|
|
{
|
|
|
|
|
mme_sess_t *sess = NULL;
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(bearer);
|
2017-09-04 15:04:05 +00:00
|
|
|
sess = bearer->sess;
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(sess);
|
2017-09-04 15:04:05 +00:00
|
|
|
|
|
|
|
|
return mme_default_bearer_in_sess(sess);
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
mme_bearer_t *mme_bearer_first(const mme_sess_t *sess)
|
2017-04-08 01:18:48 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(sess);
|
2017-04-08 01:18:48 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
return ogs_list_first(&sess->bearer_list);
|
2017-04-08 01:18:48 +00:00
|
|
|
}
|
|
|
|
|
|
2019-06-30 11:29:25 +00:00
|
|
|
mme_bearer_t *mme_bearer_next(mme_bearer_t *bearer)
|
2017-04-08 01:18:48 +00:00
|
|
|
{
|
2019-11-15 14:56:55 +00:00
|
|
|
ogs_assert(bearer);
|
2019-04-27 14:54:30 +00:00
|
|
|
return ogs_list_next(bearer);
|
2017-04-08 01:18:48 +00:00
|
|
|
}
|
2017-04-12 04:45:57 +00:00
|
|
|
|
2020-11-07 22:27:12 +00:00
|
|
|
mme_bearer_t *mme_bearer_cycle(mme_bearer_t *bearer)
|
2018-02-03 09:29:32 +00:00
|
|
|
{
|
2020-11-07 22:27:12 +00:00
|
|
|
return ogs_pool_cycle(&mme_bearer_pool, bearer);
|
2018-02-03 09:29:32 +00:00
|
|
|
}
|
|
|
|
|
|
2021-03-08 12:25:09 +00:00
|
|
|
void mme_session_remove_all(mme_ue_t *mme_ue)
|
2017-04-12 04:45:57 +00:00
|
|
|
{
|
2021-03-08 12:25:09 +00:00
|
|
|
int i;
|
2017-08-25 15:11:46 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(mme_ue);
|
2017-08-25 15:11:46 +00:00
|
|
|
|
2022-06-30 04:33:16 +00:00
|
|
|
ogs_assert(mme_ue->num_of_session <= OGS_MAX_NUM_OF_SESS);
|
2021-03-08 12:25:09 +00:00
|
|
|
for (i = 0; i < mme_ue->num_of_session; i++) {
|
|
|
|
|
if (mme_ue->session[i].name)
|
|
|
|
|
ogs_free(mme_ue->session[i].name);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mme_ue->num_of_session = 0;
|
2017-04-12 04:45:57 +00:00
|
|
|
}
|
|
|
|
|
|
2024-01-05 18:25:53 +00:00
|
|
|
ogs_session_t *mme_session_find_by_apn(mme_ue_t *mme_ue, const char *apn)
|
2017-04-12 04:45:57 +00:00
|
|
|
{
|
2021-03-08 12:25:09 +00:00
|
|
|
ogs_session_t *session = NULL;
|
2017-08-11 10:34:27 +00:00
|
|
|
int i = 0;
|
2022-03-01 08:13:40 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(mme_ue);
|
2019-11-15 14:56:55 +00:00
|
|
|
ogs_assert(apn);
|
|
|
|
|
|
2022-06-30 04:33:16 +00:00
|
|
|
ogs_assert(mme_ue->num_of_session <= OGS_MAX_NUM_OF_SESS);
|
2021-03-08 12:25:09 +00:00
|
|
|
for (i = 0; i < mme_ue->num_of_session; i++) {
|
|
|
|
|
session = &mme_ue->session[i];
|
|
|
|
|
ogs_assert(session->name);
|
|
|
|
|
if (ogs_strcasecmp(session->name, apn) == 0)
|
|
|
|
|
return session;
|
2017-04-12 04:45:57 +00:00
|
|
|
}
|
|
|
|
|
|
2017-08-19 07:49:44 +00:00
|
|
|
return NULL;
|
2017-04-12 04:45:57 +00:00
|
|
|
}
|
2017-12-11 07:08:17 +00:00
|
|
|
|
2021-03-08 12:25:09 +00:00
|
|
|
ogs_session_t *mme_default_session(mme_ue_t *mme_ue)
|
2017-12-19 08:05:54 +00:00
|
|
|
{
|
2021-03-08 12:25:09 +00:00
|
|
|
ogs_session_t *session = NULL;
|
2017-12-19 08:05:54 +00:00
|
|
|
int i = 0;
|
2022-03-01 08:13:40 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(mme_ue);
|
2017-12-19 08:05:54 +00:00
|
|
|
|
2022-06-30 04:33:16 +00:00
|
|
|
ogs_assert(mme_ue->num_of_session <= OGS_MAX_NUM_OF_SESS);
|
2021-03-08 12:25:09 +00:00
|
|
|
for (i = 0; i < mme_ue->num_of_session; i++) {
|
|
|
|
|
session = &mme_ue->session[i];
|
|
|
|
|
if (session->context_identifier == mme_ue->context_identifier)
|
|
|
|
|
return session;
|
2017-12-19 08:05:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-25 16:15:22 +00:00
|
|
|
int mme_find_served_tai(ogs_eps_tai_t *tai)
|
2017-12-11 07:08:17 +00:00
|
|
|
{
|
|
|
|
|
int i = 0, j = 0, k = 0;
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(tai);
|
2017-12-11 07:08:17 +00:00
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
for (i = 0; i < self.num_of_served_tai; i++) {
|
2020-05-25 16:15:22 +00:00
|
|
|
ogs_eps_tai0_list_t *list0 = &self.served_tai[i].list0;
|
2023-03-19 09:25:59 +00:00
|
|
|
ogs_eps_tai1_list_t *list1 = &self.served_tai[i].list1;
|
2020-05-25 16:15:22 +00:00
|
|
|
ogs_eps_tai2_list_t *list2 = &self.served_tai[i].list2;
|
2017-12-11 07:08:17 +00:00
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
for (j = 0; list0->tai[j].num; j++) {
|
2020-05-25 16:15:22 +00:00
|
|
|
ogs_assert(list0->tai[j].type == OGS_TAI0_TYPE);
|
2023-03-19 09:25:59 +00:00
|
|
|
ogs_assert(list0->tai[j].num <= OGS_MAX_NUM_OF_TAI);
|
2017-12-11 07:08:17 +00:00
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
for (k = 0; k < list0->tai[j].num; k++) {
|
2017-12-11 07:08:17 +00:00
|
|
|
if (memcmp(&list0->tai[j].plmn_id,
|
2022-03-01 08:13:40 +00:00
|
|
|
&tai->plmn_id, OGS_PLMN_ID_LEN) == 0 &&
|
2019-05-29 12:27:22 +00:00
|
|
|
list0->tai[j].tac[k] == tai->tac) {
|
2017-12-11 07:08:17 +00:00
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2023-03-19 09:25:59 +00:00
|
|
|
for (j = 0; list1->tai[j].num; j++) {
|
|
|
|
|
ogs_assert(list1->tai[j].type == OGS_TAI1_TYPE);
|
|
|
|
|
ogs_assert(list1->tai[j].num <= OGS_MAX_NUM_OF_TAI);
|
|
|
|
|
|
|
|
|
|
if (list1->tai[j].tac <= tai->tac &&
|
|
|
|
|
tai->tac < (list1->tai[j].tac+list1->tai[j].num))
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
if (list2->num) {
|
2023-03-19 09:25:59 +00:00
|
|
|
ogs_assert(list2->type == OGS_TAI2_TYPE);
|
|
|
|
|
ogs_assert(list2->num <= OGS_MAX_NUM_OF_TAI);
|
2017-12-11 07:08:17 +00:00
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
for (j = 0; j < list2->num; j++) {
|
2017-12-11 07:08:17 +00:00
|
|
|
if (memcmp(&list2->tai[j].plmn_id,
|
2022-03-01 08:13:40 +00:00
|
|
|
&tai->plmn_id, OGS_PLMN_ID_LEN) == 0 &&
|
2019-05-29 12:27:22 +00:00
|
|
|
list2->tai[j].tac == tai->tac) {
|
2017-12-11 07:08:17 +00:00
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2018-01-21 06:44:30 +00:00
|
|
|
|
2023-04-09 01:34:19 +00:00
|
|
|
#if 0 /* DEPRECATED */
|
2023-04-04 12:53:39 +00:00
|
|
|
int mme_m_tmsi_pool_generate(void)
|
2018-01-21 06:44:30 +00:00
|
|
|
{
|
2023-04-04 12:53:39 +00:00
|
|
|
int j;
|
2018-01-21 13:36:49 +00:00
|
|
|
int index = 0;
|
2018-01-21 06:44:30 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_trace("M-TMSI Pool try to generate...");
|
2023-11-19 10:34:51 +00:00
|
|
|
while (index < ogs_global_conf()->max.ue*2) {
|
2018-01-21 06:44:30 +00:00
|
|
|
mme_m_tmsi_t *m_tmsi = NULL;
|
2018-01-21 07:53:39 +00:00
|
|
|
int conflict = 0;
|
2018-01-21 06:44:30 +00:00
|
|
|
|
2023-04-09 01:34:19 +00:00
|
|
|
m_tmsi = &m_tmsi_pool.array[index];
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(m_tmsi);
|
|
|
|
|
*m_tmsi = ogs_random32();
|
2018-01-25 21:52:30 +00:00
|
|
|
|
|
|
|
|
/* for mapped-GUTI */
|
|
|
|
|
*m_tmsi |= 0xc0000000;
|
|
|
|
|
*m_tmsi &= 0xff00ffff;
|
|
|
|
|
|
2019-05-29 12:27:22 +00:00
|
|
|
for (j = 0; j < index; j++) {
|
2023-04-09 01:34:19 +00:00
|
|
|
if (*m_tmsi == m_tmsi_pool.array[j]) {
|
2018-01-21 07:53:39 +00:00
|
|
|
conflict = 1;
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_trace("[M-TMSI CONFLICT] %d:0x%x == %d:0x%x",
|
2023-04-09 01:34:19 +00:00
|
|
|
index, *m_tmsi, j, m_tmsi_pool.array[j]);
|
2018-01-21 07:53:39 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-05-29 12:27:22 +00:00
|
|
|
if (conflict == 1) {
|
2019-04-27 14:54:30 +00:00
|
|
|
continue;
|
|
|
|
|
}
|
2018-01-25 21:52:30 +00:00
|
|
|
|
2018-01-21 13:36:49 +00:00
|
|
|
index++;
|
2018-01-21 06:44:30 +00:00
|
|
|
}
|
2023-04-09 01:34:19 +00:00
|
|
|
m_tmsi_pool.size = index;
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_trace("M-TMSI Pool generate...done");
|
2018-01-21 06:44:30 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_OK;
|
2018-01-21 06:44:30 +00:00
|
|
|
}
|
2023-04-09 01:34:19 +00:00
|
|
|
#endif
|
2018-01-21 06:44:30 +00:00
|
|
|
|
2023-04-04 12:53:39 +00:00
|
|
|
mme_m_tmsi_t *mme_m_tmsi_alloc(void)
|
2018-01-21 06:44:30 +00:00
|
|
|
{
|
|
|
|
|
mme_m_tmsi_t *m_tmsi = NULL;
|
|
|
|
|
|
2023-04-09 01:34:19 +00:00
|
|
|
ogs_pool_alloc(&m_tmsi_pool, &m_tmsi);
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(m_tmsi);
|
2018-01-21 06:44:30 +00:00
|
|
|
|
2023-04-09 01:34:19 +00:00
|
|
|
/* TS23.003
|
|
|
|
|
* 2.8.2.1.2 Mapping in the UE
|
|
|
|
|
*
|
|
|
|
|
* E-UTRAN <M-TMSI> maps as follows:
|
|
|
|
|
* - 6 bits of the E-UTRAN <M-TMSI> starting at bit 29 and down to bit 24
|
|
|
|
|
* are mapped into bit 29 and down to bit 24 of the GERAN/UTRAN <P-TMSI>;
|
|
|
|
|
* - 16 bits of the E-UTRAN <M-TMSI> starting at bit 15 and down to bit 0
|
|
|
|
|
* are mapped into bit 15 and down to bit 0 of the GERAN/UTRAN <P-TMSI>;
|
|
|
|
|
* - and the remaining 8 bits of the E-UTRAN <M-TMSI> are
|
|
|
|
|
* mapped into the 8 Most Significant Bits of the <P-TMSI signature> field.
|
|
|
|
|
*
|
|
|
|
|
* The UE shall fill the remaining 2 octets of the <P-TMSI signature>
|
|
|
|
|
* according to clauses 9.1.1, 9.4.1, 10.2.1, or 10.5.1
|
|
|
|
|
* of 3GPP TS.33.401 [89] , as appropriate, for RAU/Attach procedures
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
ogs_assert(*m_tmsi <= 0x003fffff);
|
|
|
|
|
|
|
|
|
|
*m_tmsi = ((*m_tmsi & 0xffff) | ((*m_tmsi & 0x003f0000) << 8));
|
|
|
|
|
*m_tmsi |= 0xc0000000;
|
|
|
|
|
|
2018-01-21 06:44:30 +00:00
|
|
|
return m_tmsi;
|
|
|
|
|
}
|
|
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
int mme_m_tmsi_free(mme_m_tmsi_t *m_tmsi)
|
2018-01-21 06:44:30 +00:00
|
|
|
{
|
2019-04-27 14:54:30 +00:00
|
|
|
ogs_assert(m_tmsi);
|
2023-05-14 01:34:36 +00:00
|
|
|
|
|
|
|
|
/* Restore M-TMSI by Issue #2307 */
|
2024-01-21 02:55:46 +00:00
|
|
|
*m_tmsi &= 0x3fffffff;
|
|
|
|
|
*m_tmsi = ((*m_tmsi & 0xffff) | ((*m_tmsi & 0x3f000000) >> 8));
|
2023-04-09 01:34:19 +00:00
|
|
|
ogs_pool_free(&m_tmsi_pool, m_tmsi);
|
2018-01-21 06:44:30 +00:00
|
|
|
|
2019-04-27 14:54:30 +00:00
|
|
|
return OGS_OK;
|
2018-01-21 06:44:30 +00:00
|
|
|
}
|
|
|
|
|
|
2020-08-30 03:27:54 +00:00
|
|
|
void mme_ebi_pool_init(mme_ue_t *mme_ue)
|
|
|
|
|
{
|
|
|
|
|
int i, index;
|
|
|
|
|
|
|
|
|
|
ogs_assert(mme_ue);
|
|
|
|
|
|
2023-05-28 13:47:10 +00:00
|
|
|
ogs_pool_create(&mme_ue->ebi_pool, MAX_EPS_BEARER_ID-MIN_EPS_BEARER_ID+1);
|
2020-08-30 03:27:54 +00:00
|
|
|
|
|
|
|
|
for (i = MIN_EPS_BEARER_ID, index = 0;
|
|
|
|
|
i <= MAX_EPS_BEARER_ID; i++, index++) {
|
|
|
|
|
mme_ue->ebi_pool.array[index] = i;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void mme_ebi_pool_final(mme_ue_t *mme_ue)
|
|
|
|
|
{
|
2020-09-02 03:04:35 +00:00
|
|
|
ogs_assert(mme_ue);
|
|
|
|
|
|
2023-05-28 13:47:10 +00:00
|
|
|
ogs_pool_destroy(&mme_ue->ebi_pool);
|
2020-09-02 03:04:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void mme_ebi_pool_clear(mme_ue_t *mme_ue)
|
|
|
|
|
{
|
|
|
|
|
ogs_assert(mme_ue);
|
|
|
|
|
|
2023-04-09 01:34:19 +00:00
|
|
|
/* Suppress log message (mme_ue->ebi_pool.avail != mme_ue->ebi_pool.size) */
|
|
|
|
|
mme_ue->ebi_pool.avail = mme_ue->ebi_pool.size;
|
2020-09-02 03:04:35 +00:00
|
|
|
|
2023-04-09 01:34:19 +00:00
|
|
|
mme_ebi_pool_final(mme_ue);
|
2020-09-02 03:04:35 +00:00
|
|
|
mme_ebi_pool_init(mme_ue);
|
2020-08-30 03:27:54 +00:00
|
|
|
}
|
|
|
|
|
|
2019-07-13 14:47:24 +00:00
|
|
|
uint8_t mme_selected_int_algorithm(mme_ue_t *mme_ue)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
ogs_assert(mme_ue);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < mme_self()->num_of_integrity_order; i++) {
|
2022-03-01 08:13:40 +00:00
|
|
|
if (mme_ue->ue_network_capability.eia &
|
2019-07-13 14:47:24 +00:00
|
|
|
(0x80 >> mme_self()->integrity_order[i])) {
|
|
|
|
|
return mme_self()->integrity_order[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint8_t mme_selected_enc_algorithm(mme_ue_t *mme_ue)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
ogs_assert(mme_ue);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < mme_self()->num_of_ciphering_order; i++) {
|
2022-03-01 08:13:40 +00:00
|
|
|
if (mme_ue->ue_network_capability.eea &
|
2019-07-13 14:47:24 +00:00
|
|
|
(0x80 >> mme_self()->ciphering_order[i])) {
|
|
|
|
|
return mme_self()->ciphering_order[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2020-09-05 03:36:51 +00:00
|
|
|
|
|
|
|
|
static void stats_add_enb_ue(void)
|
|
|
|
|
{
|
2022-06-08 21:23:51 +00:00
|
|
|
mme_metrics_inst_global_inc(MME_METR_GLOB_GAUGE_ENB_UE);
|
2020-09-05 03:36:51 +00:00
|
|
|
num_of_enb_ue = num_of_enb_ue + 1;
|
|
|
|
|
ogs_info("[Added] Number of eNB-UEs is now %d", num_of_enb_ue);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void stats_remove_enb_ue(void)
|
|
|
|
|
{
|
2022-06-08 21:23:51 +00:00
|
|
|
mme_metrics_inst_global_dec(MME_METR_GLOB_GAUGE_ENB_UE);
|
2020-09-05 03:36:51 +00:00
|
|
|
num_of_enb_ue = num_of_enb_ue - 1;
|
|
|
|
|
ogs_info("[Removed] Number of eNB-UEs is now %d", num_of_enb_ue);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void stats_add_mme_session(void)
|
|
|
|
|
{
|
2022-06-08 21:23:51 +00:00
|
|
|
mme_metrics_inst_global_inc(MME_METR_GLOB_GAUGE_MME_SESS);
|
2020-09-05 03:36:51 +00:00
|
|
|
num_of_mme_sess = num_of_mme_sess + 1;
|
|
|
|
|
ogs_info("[Added] Number of MME-Sessions is now %d", num_of_mme_sess);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void stats_remove_mme_session(void)
|
|
|
|
|
{
|
2022-06-08 21:23:51 +00:00
|
|
|
mme_metrics_inst_global_dec(MME_METR_GLOB_GAUGE_MME_SESS);
|
2020-09-05 03:36:51 +00:00
|
|
|
num_of_mme_sess = num_of_mme_sess - 1;
|
|
|
|
|
ogs_info("[Removed] Number of MME-Sessions is now %d", num_of_mme_sess);
|
|
|
|
|
}
|
