gfwleak/stellar-stellar
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

modify session manager related configuration

Browse Source
This commit is contained in:
luwenpeng
2024-08-29 16:25:15 +08:00
parent 419d12760e
commit 338dcf93e5
31 changed files with 928 additions and 1093 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
conf/stellar.toml
View File

@@ -10,7 +10,7 @@ dev_symbol = "nf_0_fw"
dumpfile_path = "/tmp/dumpfile/dumpfile.pcap"
#dumpfile_path = "/tmp/dumpfile/dumpfilelist"
nr_threads = 1 # [1, 256]
nr_worker_thread = 1 # [1, 256]
cpu_mask = [5, 6, 7, 8, 9, 10, 11, 12]
[ip_reassembly]
@@ -29,40 +29,39 @@ tcp_overload_evict_old_sess = 1 # 1: evict old session, 0: bypass new session
udp_overload_evict_old_sess = 1 # 1: evict old session, 0: bypass new session
# TCP timeout
tcp_init_timeout = 5000 # range: [1, 60000] (ms)
tcp_handshake_timeout = 5000 # range: [1, 60000] (ms)
tcp_data_timeout = 5000 # range: [1, 15999999000] (ms)
tcp_half_closed_timeout = 5000 # range: [1, 604800000] (ms)
tcp_time_wait_timeout = 5000 # range: [1, 600000] (ms)
tcp_discard_timeout = 10000 # range: [1, 15999999000] (ms)
tcp_unverified_rst_timeout = 5000 # range: [1, 600000] (ms)
tcp_init_timeout_ms = 5000 # range: [1, 60000] (ms)
tcp_handshake_timeout_ms = 5000 # range: [1, 60000] (ms)
tcp_data_timeout_ms = 5000 # range: [1, 15999999000] (ms)
tcp_half_closed_timeout_ms = 5000 # range: [1, 604800000] (ms)
tcp_time_wait_timeout_ms = 5000 # range: [1, 600000] (ms)
tcp_discard_timeout_ms = 10000 # range: [1, 15999999000] (ms)
tcp_unverified_rst_timeout_ms = 5000 # range: [1, 600000] (ms)
# UDP timeout
udp_data_timeout = 5000 # range: [1, 15999999000] (ms)
udp_discard_timeout = 5000 # range: [1, 15999999000] (ms)
udp_data_timeout_ms = 5000 # range: [1, 15999999000] (ms)
udp_discard_timeout_ms = 5000 # range: [1, 15999999000] (ms)
# limit
session_expire_polling_interval_ms = 0 # range: [0, 60000] (ms)
session_expire_polling_limit = 1024 # range: [1, 1024]
# duplicate packet filter
duplicated_packet_filter_enable = 1
duplicated_packet_filter_capacity = 1000000 # range: [1, 4294967295]
duplicated_packet_filter_timeout = 10000 # range: [1, 60000] (ms)
duplicated_packet_filter_timeout_ms = 10000 # range: [1, 60000] (ms)
duplicated_packet_filter_error_rate = 0.00001 # range: [0.0, 1.0]
# evicted session filter
evicted_session_filter_enable = 1
evicted_session_filter_capacity = 1000000 # range: [1, 4294967295]
evicted_session_filter_timeout = 10000 # range: [1, 60000] (ms)
evicted_session_filter_timeout_ms = 10000 # range: [1, 60000] (ms)
evicted_session_filter_error_rate = 0.00001 # range: [0.0, 1.0]
# TCP reassembly (Per direction)
tcp_reassembly_enable = 1
tcp_reassembly_max_timeout = 10000 # range: [1, 60000] (ms)
tcp_reassembly_max_segments = 256 # range: [2, 4096]
tcp_reassembly_max_timeout_ms = 10000 # range: [1, 60000] (ms)
tcp_reassembly_max_segments = 256 # range: [2, 4096]
[schedule]
# Note: free_expired_session_interval determines the precision of session_manager timeout
free_expired_session_interval = 50 # range: [1, 60000] (ms)
free_expired_session_batch = 1000 # range: [1, 60000]
force_session_expire_before_exit = 0 # 1: force session to expire before exit, 0: wait for session to naturally expire before exit.
# Note: free_expired_ip_frag_interval determines the precision of ip_reassembly timeout
free_expired_ip_frag_interval = 50 # range: [1, 60000] (ms)
free_expired_ip_frag_batch = 1000 # range: [1, 60000]

313
infra/core/stellar_config.c
View File

@@ -115,18 +115,18 @@ static int parse_packet_io_section(toml_table_t *root, struct packet_io_options
strcpy(opts->dev_symbol, ptr_dev_symbol);
}
ptr = toml_raw_in(table, "nr_threads");
ptr = toml_raw_in(table, "nr_worker_thread");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing packet_io->nr_threads");
CONFIG_LOG_ERROR("config file missing packet_io->nr_worker_thread");
goto error_out;
}
if (atoi(ptr) <= 0 || atoi(ptr) > MAX_THREAD_NUM)
{
CONFIG_LOG_ERROR("config file invalid packet_io->nr_threads %d, range [1, %d]", atoi(ptr), MAX_THREAD_NUM);
CONFIG_LOG_ERROR("config file invalid packet_io->nr_worker_thread %d, range [1, %d]", atoi(ptr), MAX_THREAD_NUM);
goto error_out;
}
opts->nr_threads = atoi(ptr);
opts->nr_worker_thread = atoi(ptr);
mask_array = toml_array_in(table, "cpu_mask");
if (mask_array == NULL)
@@ -134,7 +134,7 @@ static int parse_packet_io_section(toml_table_t *root, struct packet_io_options
CONFIG_LOG_ERROR("config file missing packet_io->cpu_mask");
goto error_out;
}
for (uint16_t i = 0; i < opts->nr_threads; i++)
for (uint16_t i = 0; i < opts->nr_worker_thread; i++)
{
ptr = toml_raw_at(mask_array, i);
if (ptr == NULL)
@@ -217,222 +217,6 @@ static int parse_ip_reassembly_section(toml_table_t *root, struct ip_reassembly_
return 0;
}
// return 0: success
// retuun -1: failed
static int parse_session_manager_section(toml_table_t *root, struct session_manager_options *opts)
{
const char *ptr;
toml_table_t *table;
table = toml_table_in(root, "session_manager");
if (table == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager section");
return -1;
}
// max session number
ptr = toml_raw_in(table, "max_tcp_session_num");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->max_tcp_session_num");
return -1;
}
opts->max_tcp_session_num = atoll(ptr);
ptr = toml_raw_in(table, "max_udp_session_num");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->max_udp_session_num");
return -1;
}
opts->max_udp_session_num = atoll(ptr);
// session overload (1: evict old session, 0: bypass new session)
ptr = toml_raw_in(table, "tcp_overload_evict_old_sess");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->tcp_overload_evict_old_sess");
return -1;
}
opts->tcp_overload_evict_old_sess = atoi(ptr);
ptr = toml_raw_in(table, "udp_overload_evict_old_sess");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->udp_overload_evict_old_sess");
return -1;
}
opts->udp_overload_evict_old_sess = atoi(ptr);
// TCP timeout
ptr = toml_raw_in(table, "tcp_init_timeout");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->tcp_init_timeout");
return -1;
}
opts->tcp_init_timeout = atoll(ptr);
ptr = toml_raw_in(table, "tcp_handshake_timeout");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->tcp_handshake_timeout");
return -1;
}
opts->tcp_handshake_timeout = atoll(ptr);
ptr = toml_raw_in(table, "tcp_data_timeout");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->tcp_data_timeout");
return -1;
}
opts->tcp_data_timeout = atoll(ptr);
ptr = toml_raw_in(table, "tcp_half_closed_timeout");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->tcp_half_closed_timeout");
return -1;
}
opts->tcp_half_closed_timeout = atoll(ptr);
ptr = toml_raw_in(table, "tcp_time_wait_timeout");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->tcp_time_wait_timeout");
return -1;
}
opts->tcp_time_wait_timeout = atoll(ptr);
ptr = toml_raw_in(table, "tcp_discard_timeout");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->tcp_discard_timeout");
return -1;
}
opts->tcp_discard_timeout = atoll(ptr);
ptr = toml_raw_in(table, "tcp_unverified_rst_timeout");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->tcp_unverified_rst_timeout");
return -1;
}
opts->tcp_unverified_rst_timeout = atoll(ptr);
// UDP timeout
ptr = toml_raw_in(table, "udp_data_timeout");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->udp_data_timeout");
return -1;
}
opts->udp_data_timeout = atoll(ptr);
ptr = toml_raw_in(table, "udp_discard_timeout");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->udp_discard_timeout");
return -1;
}
opts->udp_discard_timeout = atoll(ptr);
// duplicate packet filter
ptr = toml_raw_in(table, "duplicated_packet_filter_enable");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->duplicated_packet_filter_enable");
return -1;
}
opts->duplicated_packet_filter_enable = atoi(ptr);
ptr = toml_raw_in(table, "duplicated_packet_filter_capacity");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->duplicated_packet_filter_capacity");
return -1;
}
opts->duplicated_packet_filter_capacity = atoi(ptr);
ptr = toml_raw_in(table, "duplicated_packet_filter_timeout");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->duplicated_packet_filter_timeout");
return -1;
}
opts->duplicated_packet_filter_timeout = atoi(ptr);
ptr = toml_raw_in(table, "duplicated_packet_filter_error_rate");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->duplicated_packet_filter_error_rate");
return -1;
}
opts->duplicated_packet_filter_error_rate = atof(ptr);
// eviction session filter
ptr = toml_raw_in(table, "evicted_session_filter_enable");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->evicted_session_filter_enable");
return -1;
}
opts->evicted_session_filter_enable = atoi(ptr);
ptr = toml_raw_in(table, "evicted_session_filter_capacity");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->evicted_session_filter_capacity");
return -1;
}
opts->evicted_session_filter_capacity = atoi(ptr);
ptr = toml_raw_in(table, "evicted_session_filter_timeout");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->evicted_session_filter_timeout");
return -1;
}
opts->evicted_session_filter_timeout = atoi(ptr);
ptr = toml_raw_in(table, "evicted_session_filter_error_rate");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->evicted_session_filter_error_rate");
return -1;
}
opts->evicted_session_filter_error_rate = atof(ptr);
// TCP reassembly
ptr = toml_raw_in(table, "tcp_reassembly_enable");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->tcp_reassembly_enable");
return -1;
}
opts->tcp_reassembly_enable = atoi(ptr);
ptr = toml_raw_in(table, "tcp_reassembly_max_timeout");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->tcp_reassembly_max_timeout");
return -1;
}
opts->tcp_reassembly_max_timeout = atoi(ptr);
ptr = toml_raw_in(table, "tcp_reassembly_max_segments");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing session_manager->tcp_reassembly_max_segments");
return -1;
}
opts->tcp_reassembly_max_segments = atoi(ptr);
return 0;
}
// return 0: success
// retuun -1: failed
static int parse_schedule_options(toml_table_t *root, struct schedule_options *opts)
@@ -447,45 +231,6 @@ static int parse_schedule_options(toml_table_t *root, struct schedule_options *o
return -1;
}
ptr = toml_raw_in(table, "free_expired_session_interval");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing schedule->free_expired_session_interval");
return -1;
}
opts->free_expired_session_interval = atoll(ptr);
if (opts->free_expired_session_interval < 1 || opts->free_expired_session_interval > 60000)
{
CONFIG_LOG_ERROR("config file invalid schedule->free_expired_session_interval %ld, range [1, 60000]", opts->free_expired_session_interval);
return -1;
}
ptr = toml_raw_in(table, "free_expired_session_batch");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing schedule->free_expired_session_batch");
return -1;
}
opts->free_expired_session_batch = atoll(ptr);
if (opts->free_expired_session_batch < 1 || opts->free_expired_session_batch > 60000)
{
CONFIG_LOG_ERROR("config file invalid schedule->free_expired_session_batch %ld, range [1, 60000]", opts->free_expired_session_batch);
return -1;
}
ptr = toml_raw_in(table, "force_session_expire_before_exit");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing schedule->force_session_expire_before_exit");
return -1;
}
opts->force_session_expire_before_exit = atoll(ptr);
if (opts->force_session_expire_before_exit != 0 && opts->force_session_expire_before_exit != 1)
{
CONFIG_LOG_ERROR("config file invalid schedule->force_session_expire_before_exit %ld, range [0, 1]", opts->force_session_expire_before_exit);
return -1;
}
ptr = toml_raw_in(table, "free_expired_ip_frag_interval");
if (ptr == NULL)
{
@@ -592,11 +337,6 @@ int stellar_config_load(struct stellar_config *config, const char *file)
goto error_out;
}
if (parse_session_manager_section(table, &config->sess_mgr_opts) != 0)
{
goto error_out;
}
if (parse_schedule_options(table, &config->sched_opts) != 0)
{
goto error_out;
@@ -628,7 +368,6 @@ void stellar_config_print(const struct stellar_config *config)
const struct packet_io_options *pkt_io_opts = &config->pkt_io_opts;
const struct snowflake_options *snowflake_opts = &config->snowflake_opts;
const struct ip_reassembly_options *ip_reass_opts = &config->ip_reass_opts;
const struct session_manager_options *sess_mgr_opts = &config->sess_mgr_opts;
// snowflake config
CONFIG_LOG_DEBUG("snowflake->snowflake_base : %d", snowflake_opts->snowflake_base);
@@ -645,8 +384,8 @@ void stellar_config_print(const struct stellar_config *config)
CONFIG_LOG_DEBUG("packet_io->app_symbol : %s", pkt_io_opts->app_symbol);
CONFIG_LOG_DEBUG("packet_io->dev_symbol : %s", pkt_io_opts->dev_symbol);
}
CONFIG_LOG_DEBUG("packet_io->nr_threads : %d", pkt_io_opts->nr_threads);
for (uint16_t i = 0; i < pkt_io_opts->nr_threads; i++)
CONFIG_LOG_DEBUG("packet_io->nr_worker_thread : %d", pkt_io_opts->nr_worker_thread);
for (uint16_t i = 0; i < pkt_io_opts->nr_worker_thread; i++)
{
CONFIG_LOG_DEBUG("packet_io->cpu_mask[%3d] : %d", i, pkt_io_opts->cpu_mask[i]);
}
@@ -657,45 +396,7 @@ void stellar_config_print(const struct stellar_config *config)
CONFIG_LOG_DEBUG("ip_reassembly->bucket_entries : %d", ip_reass_opts->bucket_entries);
CONFIG_LOG_DEBUG("ip_reassembly->bucket_num : %d", ip_reass_opts->bucket_num);
// session manager config -> max session number
CONFIG_LOG_DEBUG("session_manager->max_tcp_session_num : %ld", sess_mgr_opts->max_tcp_session_num);
CONFIG_LOG_DEBUG("session_manager->max_udp_session_num : %ld", sess_mgr_opts->max_udp_session_num);
// session manager config -> session overload evict
CONFIG_LOG_DEBUG("session_manager->tcp_overload_evict_old_sess : %d", sess_mgr_opts->tcp_overload_evict_old_sess);
CONFIG_LOG_DEBUG("session_manager->udp_overload_evict_old_sess : %d", sess_mgr_opts->udp_overload_evict_old_sess);
// session manager config -> session timeout
CONFIG_LOG_DEBUG("session_manager->tcp_init_timeout : %ld", sess_mgr_opts->tcp_init_timeout);
CONFIG_LOG_DEBUG("session_manager->tcp_handshake_timeout : %ld", sess_mgr_opts->tcp_handshake_timeout);
CONFIG_LOG_DEBUG("session_manager->tcp_data_timeout : %ld", sess_mgr_opts->tcp_data_timeout);
CONFIG_LOG_DEBUG("session_manager->tcp_half_closed_timeout : %ld", sess_mgr_opts->tcp_half_closed_timeout);
CONFIG_LOG_DEBUG("session_manager->tcp_time_wait_timeout : %ld", sess_mgr_opts->tcp_time_wait_timeout);
CONFIG_LOG_DEBUG("session_manager->tcp_discard_timeout : %ld", sess_mgr_opts->tcp_discard_timeout);
CONFIG_LOG_DEBUG("session_manager->tcp_unverified_rst_timeout : %ld", sess_mgr_opts->tcp_unverified_rst_timeout);
CONFIG_LOG_DEBUG("session_manager->udp_data_timeout : %ld", sess_mgr_opts->udp_data_timeout);
CONFIG_LOG_DEBUG("session_manager->udp_discard_timeout : %ld", sess_mgr_opts->udp_discard_timeout);
// session manager config -> duplicated packet filter
CONFIG_LOG_DEBUG("session_manager->duplicated_packet_filter_enable : %d", sess_mgr_opts->duplicated_packet_filter_enable);
CONFIG_LOG_DEBUG("session_manager->duplicated_packet_filter_capacity : %d", sess_mgr_opts->duplicated_packet_filter_capacity);
CONFIG_LOG_DEBUG("session_manager->duplicated_packet_filter_timeout : %d", sess_mgr_opts->duplicated_packet_filter_timeout);
CONFIG_LOG_DEBUG("session_manager->duplicated_packet_filter_error_rate : %f", sess_mgr_opts->duplicated_packet_filter_error_rate);
// session manager config -> evicted session filter
CONFIG_LOG_DEBUG("session_manager->evicted_session_filter_enable : %d", sess_mgr_opts->evicted_session_filter_enable);
CONFIG_LOG_DEBUG("session_manager->evicted_session_filter_capacity : %d", sess_mgr_opts->evicted_session_filter_capacity);
CONFIG_LOG_DEBUG("session_manager->evicted_session_filter_timeout : %d", sess_mgr_opts->evicted_session_filter_timeout);
CONFIG_LOG_DEBUG("session_manager->evicted_session_filter_error_rate : %f", sess_mgr_opts->evicted_session_filter_error_rate);
// session manager config -> TCP reassembly
CONFIG_LOG_DEBUG("session_manager->tcp_reassembly_enable : %d", sess_mgr_opts->tcp_reassembly_enable);
CONFIG_LOG_DEBUG("session_manager->tcp_reassembly_max_timeout : %d", sess_mgr_opts->tcp_reassembly_max_timeout);
CONFIG_LOG_DEBUG("session_manager->tcp_reassembly_max_segments : %d", sess_mgr_opts->tcp_reassembly_max_segments);
// schedule config
CONFIG_LOG_DEBUG("schedule->free_expired_session_interval : %ld", config->sched_opts.free_expired_session_interval);
CONFIG_LOG_DEBUG("schedule->free_expired_session_batch : %ld", config->sched_opts.free_expired_session_batch);
CONFIG_LOG_DEBUG("schedule->free_expired_ip_frag_interval : %ld", config->sched_opts.free_expired_ip_frag_interval);
CONFIG_LOG_DEBUG("schedule->free_expired_ip_frag_batch : %ld", config->sched_opts.free_expired_ip_frag_batch);
CONFIG_LOG_DEBUG("schedule->merge_stat_interval : %ld", config->sched_opts.merge_stat_interval);

7
infra/core/stellar_config.h
View File

@@ -7,15 +7,9 @@ extern "C"
#include "packet_io.h"
#include "ip_reassembly.h"
#include "session_manager.h"
struct schedule_options
{
// Note: free_expired_session_interval determines the precision of session_manager timeout
uint64_t free_expired_session_interval; // range: [1, 60000] (ms)
uint64_t free_expired_session_batch; // range: [1, 60000]
uint64_t force_session_expire_before_exit; // range: [0, 1]
// Note: free_expired_ip_frag_interval determines the precision of ip_reassembly timeout
uint64_t free_expired_ip_frag_interval; // range: [1, 60000] (ms)
uint64_t free_expired_ip_frag_batch; // range: [1, 60000]
@@ -37,7 +31,6 @@ struct stellar_config
struct packet_io_options pkt_io_opts;
struct snowflake_options snowflake_opts;
struct ip_reassembly_options ip_reass_opts;
struct session_manager_options sess_mgr_opts;
struct schedule_options sched_opts;
};

227
infra/core/stellar_core.c
View File

@@ -42,7 +42,6 @@ struct stellar_thread
pthread_t tid;
uint16_t idx;
uint64_t is_runing;
uint64_t last_free_expired_session_timestamp;
uint64_t last_free_expired_ip_frag_timestamp;
uint64_t last_merge_thread_stat_timestamp;
struct snowflake *snowflake;
@@ -60,6 +59,7 @@ struct stellar_runtime
struct packet_io *packet_io;
struct plugin_manager_schema *plug_mgr;
struct stellar_thread threads[MAX_THREAD_NUM];
struct session_manager_config *sess_mgr_cfg;
};
struct stellar
@@ -83,101 +83,45 @@ uint64_t stellar_generate_session_id(uint64_t now_sec);
static void update_session_stat(struct session *sess, struct packet *pkt)
{
if (sess)
enum flow_direction dir = session_get_current_flow_direction(sess);
assert(dir != FLOW_DIRECTION_NONE);
int is_ctrl = packet_is_ctrl(pkt);
uint16_t len = packet_get_raw_len(pkt);
switch (packet_get_action(pkt))
{
enum flow_direction dir = session_get_current_flow_direction(sess);
assert(dir != FLOW_DIRECTION_NONE);
int is_ctrl = packet_is_ctrl(pkt);
uint16_t len = packet_get_raw_len(pkt);
switch (packet_get_action(pkt))
{
case PACKET_ACTION_DROP:
session_inc_stat(sess, dir, (is_ctrl ? STAT_CONTROL_PACKETS_DROPPED : STAT_RAW_PACKETS_DROPPED), 1);
session_inc_stat(sess, dir, (is_ctrl ? STAT_CONTROL_BYTES_DROPPED : STAT_RAW_BYTES_DROPPED), len);
break;
case PACKET_ACTION_FORWARD:
session_inc_stat(sess, dir, (is_ctrl ? STAT_CONTROL_PACKETS_TRANSMITTED : STAT_RAW_PACKETS_TRANSMITTED), 1);
session_inc_stat(sess, dir, (is_ctrl ? STAT_CONTROL_BYTES_TRANSMITTED : STAT_RAW_BYTES_TRANSMITTED), len);
break;
default:
assert(0);
break;
}
session_set_current_packet(sess, NULL);
session_set_current_flow_direction(sess, FLOW_DIRECTION_NONE);
case PACKET_ACTION_DROP:
session_inc_stat(sess, dir, (is_ctrl ? STAT_CONTROL_PACKETS_DROPPED : STAT_RAW_PACKETS_DROPPED), 1);
session_inc_stat(sess, dir, (is_ctrl ? STAT_CONTROL_BYTES_DROPPED : STAT_RAW_BYTES_DROPPED), len);
break;
case PACKET_ACTION_FORWARD:
session_inc_stat(sess, dir, (is_ctrl ? STAT_CONTROL_PACKETS_TRANSMITTED : STAT_RAW_PACKETS_TRANSMITTED), 1);
session_inc_stat(sess, dir, (is_ctrl ? STAT_CONTROL_BYTES_TRANSMITTED : STAT_RAW_BYTES_TRANSMITTED), len);
break;
default:
assert(0);
break;
}
}
static inline void free_evicted_sessions(struct session_manager *sess_mgr, uint64_t max_free)
static inline void clean_session(struct session_manager *sess_mgr, uint64_t now_ms)
{
void *plugin_ctx = NULL;
struct plugin_manager_runtime *plugin_ctx = NULL;
struct session *sess = NULL;
for (uint64_t i = 0; i < max_free; i++)
struct session *cleaned_sess[RX_BURST_MAX * 16];
uint64_t nr_sess_cleaned = session_manager_clean_session(sess_mgr, now_ms, cleaned_sess, sizeof(cleaned_sess) / sizeof(cleaned_sess[0]));
for (uint64_t j = 0; j < nr_sess_cleaned; j++)
{
sess = session_manager_get_evicted_session(sess_mgr);
if (sess)
{
plugin_ctx = session_get_user_data(sess);
plugin_manager_on_session_closing(sess);
plugin_manager_session_runtime_free((struct plugin_manager_runtime *)plugin_ctx);
session_manager_free_session(sess_mgr, sess);
}
else
{
break;
}
sess = cleaned_sess[j];
plugin_ctx = (struct plugin_manager_runtime *)session_get_user_data(sess);
plugin_manager_on_session_closing(sess);
plugin_manager_session_runtime_free(plugin_ctx);
session_manager_free_session(sess_mgr, sess);
}
}
static inline void free_expired_sessions(struct session_manager *sess_mgr, uint64_t max_free, uint64_t now_ms)
{
void *plugin_ctx = NULL;
struct session *sess = NULL;
for (uint64_t i = 0; i < max_free; i++)
{
sess = session_manager_get_expired_session(sess_mgr, now_ms);
if (sess)
{
plugin_ctx = session_get_user_data(sess);
plugin_manager_on_session_closing(sess);
plugin_manager_session_runtime_free((struct plugin_manager_runtime *)plugin_ctx);
session_manager_free_session(sess_mgr, sess);
}
else
{
break;
}
}
}
static inline void merge_thread_stat(struct stellar_thread *thread)
{
struct stellar *st = thread->st;
struct stellar_runtime *runtime = &st->runtime;
struct thread_stat thr_stat = {
.packet_io = packet_io_stat(runtime->packet_io, thread->idx),
.ip_reassembly = ip_reassembly_stat(thread->ip_mgr),
.session_mgr = session_manager_stat(thread->sess_mgr),
};
stellar_stat_merge(runtime->stat, &thr_stat, thread->idx);
}
static inline void print_thread_stat(struct stellar_thread *thread)
{
struct stellar *st = thread->st;
struct stellar_runtime *runtime = &st->runtime;
struct thread_stat thr_stat = {
.packet_io = packet_io_stat(runtime->packet_io, thread->idx),
.ip_reassembly = ip_reassembly_stat(thread->ip_mgr),
.session_mgr = session_manager_stat(thread->sess_mgr),
};
stellar_stat_print(runtime->stat, &thr_stat, thread->idx);
}
static void *worker_thread(void *arg)
{
int nr_recv;
int nr_pkt_received = 0;
uint64_t now_ms = 0;
char thd_name[16] = {0};
void *plugin_ctx = NULL;
@@ -194,9 +138,12 @@ static void *worker_thread(void *arg)
struct stellar_runtime *runtime = &st->runtime;
struct packet_io *packet_io = runtime->packet_io;
struct plugin_manager_schema *plug_mgr = runtime->plug_mgr;
uint64_t free_expired_session_interval = config->sched_opts.free_expired_session_interval;
uint64_t free_expired_session_batch = config->sched_opts.free_expired_session_batch;
uint64_t force_session_expire_before_exit = config->sched_opts.force_session_expire_before_exit;
struct thread_stat thr_stat = {
.packet_io = packet_io_stat(packet_io, thread->idx),
.ip_reassembly = ip_reassembly_stat(ip_reass),
.session_mgr = session_manager_stat(sess_mgr),
};
uint64_t free_expired_ip_frag_interval = config->sched_opts.free_expired_ip_frag_interval;
uint64_t free_expired_ip_frag_batch = config->sched_opts.free_expired_ip_frag_batch;
uint64_t merge_stat_interval = config->sched_opts.merge_stat_interval;
@@ -237,13 +184,13 @@ static void *worker_thread(void *arg)
* Suggestion: After modifying the system time, restart the service to ensure consistent timing.
*/
now_ms = clock_get_real_time_ms();
nr_recv = packet_io_input(packet_io, thr_idx, packets, RX_BURST_MAX);
if (nr_recv == 0)
nr_pkt_received = packet_io_input(packet_io, thr_idx, packets, RX_BURST_MAX);
if (nr_pkt_received == 0)
{
goto idle_tasks;
}
for (int i = 0; i < nr_recv; i++)
for (int i = 0; i < nr_pkt_received; i++)
{
sess = NULL;
defraged_pkt = NULL;
@@ -300,11 +247,19 @@ static void *worker_thread(void *arg)
plugin_manager_on_packet_output(plug_mgr, pkt);
}
if (sess && session_get_current_state(sess) == SESSION_STATE_DISCARD)
if (sess)
{
packet_set_action(pkt, PACKET_ACTION_DROP);
if (session_get_current_state(sess) == SESSION_STATE_DISCARD)
{
packet_set_action(pkt, PACKET_ACTION_DROP);
}
update_session_stat(sess, pkt);
session_set_current_packet(sess, NULL);
session_set_current_flow_direction(sess, FLOW_DIRECTION_NONE);
}
update_session_stat(sess, pkt);
if (packet_get_action(pkt) == PACKET_ACTION_DROP)
{
if (pkt == defraged_pkt)
@@ -334,21 +289,13 @@ static void *worker_thread(void *arg)
}
idle_tasks:
// nr_recv packet atmost trigger nr_recv session evicted
free_evicted_sessions(sess_mgr, nr_recv);
clean_session(sess_mgr, now_ms);
plugin_manager_on_polling(plug_mgr);
// per free_expired_session_interval MAX free_expired_session_batch sessions are released
if (now_ms - thread->last_free_expired_session_timestamp >= free_expired_session_interval)
{
free_expired_sessions(sess_mgr, free_expired_session_batch, now_ms);
thread->last_free_expired_session_timestamp = now_ms;
}
// per merge_stat_interval merge thread stat
if (now_ms - thread->last_merge_thread_stat_timestamp >= merge_stat_interval)
{
merge_thread_stat(thread);
stellar_stat_merge(runtime->stat, &thr_stat, thread->idx);
thread->last_merge_thread_stat_timestamp = now_ms;
}
@@ -359,30 +306,22 @@ static void *worker_thread(void *arg)
thread->last_free_expired_ip_frag_timestamp = now_ms;
}
if (nr_recv == 0)
if (nr_pkt_received == 0)
{
packet_io_yield(packet_io, thr_idx, packet_io_yield_interval);
}
}
// before exit wait all session close
while (sess_stat->tcp_sess_used > 0 || sess_stat->udp_sess_used > 0)
{
// force session expire
if (force_session_expire_before_exit)
{
free_expired_sessions(sess_mgr, free_expired_session_batch, UINT64_MAX);
}
// wait session expire
else
{
now_ms = clock_get_real_time_ms();
free_expired_sessions(sess_mgr, free_expired_session_batch, now_ms);
usleep(1000); // 1ms
}
now_ms = clock_get_real_time_ms();
clean_session(sess_mgr, now_ms);
usleep(1000); // 1ms
}
merge_thread_stat(thread);
print_thread_stat(thread);
stellar_stat_merge(runtime->stat, &thr_stat, thread->idx);
stellar_stat_print(runtime->stat, &thr_stat, thread->idx);
ATOMIC_SET(&thread->is_runing, 0);
CORE_LOG_FATAL("worker thread %d exit", thr_idx);
@@ -394,19 +333,32 @@ static void *worker_thread(void *arg)
* Stellar Main Function
******************************************************************************/
uint64_t stellar_generate_session_id(uint64_t now_sec)
{
if (__current_thread_snowflake == NULL)
{
printf("get current thread snowflake before set\n");
abort();
return 0;
}
else
{
return snowflake_generate(__current_thread_snowflake, now_sec);
}
}
static int stellar_thread_init(struct stellar *st)
{
struct stellar_runtime *runtime = &st->runtime;
struct stellar_config *config = &st->config;
uint64_t now_ms = clock_get_real_time_ms();
for (uint16_t i = 0; i < config->pkt_io_opts.nr_threads; i++)
for (uint16_t i = 0; i < config->pkt_io_opts.nr_worker_thread; i++)
{
struct stellar_thread *thread = &runtime->threads[i];
thread->idx = i;
thread->is_runing = 0;
thread->last_free_expired_session_timestamp = now_ms;
thread->last_free_expired_ip_frag_timestamp = now_ms;
thread->last_merge_thread_stat_timestamp = now_ms;
@@ -416,7 +368,7 @@ static int stellar_thread_init(struct stellar *st)
CORE_LOG_ERROR("unable to create snowflake id generator");
return -1;
}
thread->sess_mgr = session_manager_new(&config->sess_mgr_opts, now_ms);
thread->sess_mgr = session_manager_new(runtime->sess_mgr_cfg, now_ms);
if (thread->sess_mgr == NULL)
{
CORE_LOG_ERROR("unable to create session manager");
@@ -441,7 +393,7 @@ static void stellar_thread_clean(struct stellar *st)
struct stellar_config *config = &st->config;
CORE_LOG_FATAL("cleaning worker thread context ...");
for (uint16_t i = 0; i < config->pkt_io_opts.nr_threads; i++)
for (uint16_t i = 0; i < config->pkt_io_opts.nr_worker_thread; i++)
{
struct stellar_thread *thread = &runtime->threads[i];
if (ATOMIC_READ(&thread->is_runing) == 0)
@@ -459,7 +411,7 @@ static int stellar_thread_run(struct stellar *st)
struct stellar_runtime *runtime = &st->runtime;
struct stellar_config *config = &st->config;
for (uint16_t i = 0; i < config->pkt_io_opts.nr_threads; i++)
for (uint16_t i = 0; i < config->pkt_io_opts.nr_worker_thread; i++)
{
struct stellar_thread *thread = &runtime->threads[i];
if (pthread_create(&thread->tid, NULL, worker_thread, (void *)thread) < 0)
@@ -478,7 +430,7 @@ static void stellar_thread_join(struct stellar *st)
struct stellar_config *config = &st->config;
CORE_LOG_FATAL("waiting worker thread stop ...");
for (uint16_t i = 0; i < config->pkt_io_opts.nr_threads; i++)
for (uint16_t i = 0; i < config->pkt_io_opts.nr_worker_thread; i++)
{
struct stellar_thread *thread = &runtime->threads[i];
while (ATOMIC_READ(&thread->is_runing) == 1)
@@ -532,6 +484,14 @@ struct stellar *stellar_new(const char *stellar_cfg_file, const char *plugin_cfg
CORE_LOG_FATAL("plugin config file : %s", st->plugin_cfg_file);
CORE_LOG_FATAL("log config file : %s", st->log_cfg_file);
runtime->sess_mgr_cfg = session_manager_config_new(st->stellar_cfg_file);
if (runtime->sess_mgr_cfg == NULL)
{
CORE_LOG_ERROR("unable to create session manager config");
goto error_out;
}
session_manager_config_print(runtime->sess_mgr_cfg);
if (stellar_config_load(config, st->stellar_cfg_file) != 0)
{
CORE_LOG_ERROR("unable to load config file");
@@ -539,7 +499,7 @@ struct stellar *stellar_new(const char *stellar_cfg_file, const char *plugin_cfg
}
stellar_config_print(config);
runtime->stat = stellar_stat_new(config->pkt_io_opts.nr_threads);
runtime->stat = stellar_stat_new(config->pkt_io_opts.nr_worker_thread);
if (runtime->stat == NULL)
{
CORE_LOG_ERROR("unable to create stellar stat");
@@ -627,6 +587,7 @@ void stellar_free(struct stellar *st)
packet_io_free(runtime->packet_io);
plugin_manager_exit(runtime->plug_mgr);
stellar_stat_free(runtime->stat);
session_manager_config_free(runtime->sess_mgr_cfg);
CORE_LOG_FATAL("stellar exit\n");
log_free(runtime->logger);
@@ -691,20 +652,6 @@ uint16_t stellar_get_current_thread_index()
}
}
uint64_t stellar_generate_session_id(uint64_t now_sec)
{
if (__current_thread_snowflake == NULL)
{
printf("get current thread snowflake before set\n");
abort();
return 0;
}
else
{
return snowflake_generate(__current_thread_snowflake, now_sec);
}
}
// only send user crafted packet, can't send packet which come from network
void stellar_send_build_packet(struct stellar *st, struct packet *pkt)
{
@@ -727,7 +674,7 @@ void stellar_send_build_packet(struct stellar *st, struct packet *pkt)
int stellar_get_worker_thread_num(struct stellar *st)
{
return st->config.pkt_io_opts.nr_threads;
return st->config.pkt_io_opts.nr_worker_thread;
}
struct logger *stellar_get_logger(struct stellar *st)

14
infra/packet_io/dumpfile_io.c
View File

@@ -25,7 +25,7 @@
struct dumpfile_io
{
enum packet_io_mode mode;
uint16_t nr_threads;
uint16_t nr_worker_thread;
char dumpfile_path[256];
pcap_t *pcap;
@@ -152,7 +152,7 @@ static void pcap_pkt_handler(u_char *user, const struct pcap_pkthdr *h, const u_
uint64_t hash = packet_ldbc_hash(&pkt, PKT_LDBC_METH_OUTERMOST_INT_EXT_IP, PACKET_DIRECTION_OUTGOING);
// push packet to queue
struct packet_queue *queue = handle->queue[hash % handle->nr_threads];
struct packet_queue *queue = handle->queue[hash % handle->nr_worker_thread];
while (packet_queue_push(queue, pcap_pkt) == -1)
{
if (ATOMIC_READ(&handle->io_thread_need_exit))
@@ -199,7 +199,7 @@ static int all_packet_consumed(struct dumpfile_io *handle)
{
uint64_t consumed_pkts = 0;
uint64_t read_pcap_pkts = ATOMIC_READ(&handle->read_pcap_pkts);
for (uint16_t i = 0; i < handle->nr_threads; i++)
for (uint16_t i = 0; i < handle->nr_worker_thread; i++)
{
consumed_pkts += ATOMIC_READ(&handle->stat[i].pkts_rx);
}
@@ -287,7 +287,7 @@ erro_out:
* Public API
******************************************************************************/
struct dumpfile_io *dumpfile_io_new(const char *dumpfile_path, enum packet_io_mode mode, uint16_t nr_threads)
struct dumpfile_io *dumpfile_io_new(const char *dumpfile_path, enum packet_io_mode mode, uint16_t nr_worker_thread)
{
pthread_t tid;
struct dumpfile_io *handle = (struct dumpfile_io *)calloc(1, sizeof(struct dumpfile_io));
@@ -298,11 +298,11 @@ struct dumpfile_io *dumpfile_io_new(const char *dumpfile_path, enum packet_io_mo
}
handle->mode = mode;
handle->nr_threads = nr_threads;
handle->nr_worker_thread = nr_worker_thread;
handle->logger = __thread_local_logger;
strncpy(handle->dumpfile_path, dumpfile_path, MIN(strlen(dumpfile_path), sizeof(handle->dumpfile_path)));
for (uint16_t i = 0; i < handle->nr_threads; i++)
for (uint16_t i = 0; i < handle->nr_worker_thread; i++)
{
handle->queue[i] = packet_queue_new(MAX_PACKET_QUEUE_SIZE);
if (handle->queue[i] == NULL)
@@ -336,7 +336,7 @@ void dumpfile_io_free(struct dumpfile_io *handle)
}
struct pcap_pkt *pcap_pkt = NULL;
for (uint16_t i = 0; i < handle->nr_threads; i++)
for (uint16_t i = 0; i < handle->nr_worker_thread; i++)
{
while (1)
{

2
infra/packet_io/dumpfile_io.h
View File

@@ -8,7 +8,7 @@ extern "C"
#include "packet_io.h"
struct dumpfile_io;
struct dumpfile_io *dumpfile_io_new(const char *dumpfile_path, enum packet_io_mode mode, uint16_t nr_threads);
struct dumpfile_io *dumpfile_io_new(const char *dumpfile_path, enum packet_io_mode mode, uint16_t nr_worker_thread);
void dumpfile_io_free(struct dumpfile_io *handle);
int dumpfile_io_isbreak(struct dumpfile_io *handle);

6
infra/packet_io/marsio_io.c
View File

@@ -175,12 +175,12 @@ static inline int is_keepalive_packet(const char *data, int len)
* Public API
******************************************************************************/
struct marsio_io *marsio_io_new(const char *app_symbol, const char *dev_symbol, uint16_t *cpu_mask, uint16_t nr_threads)
struct marsio_io *marsio_io_new(const char *app_symbol, const char *dev_symbol, uint16_t *cpu_mask, uint16_t nr_worker_thread)
{
int opt = 1;
cpu_set_t coremask;
CPU_ZERO(&coremask);
for (uint16_t i = 0; i < nr_threads; i++)
for (uint16_t i = 0; i < nr_worker_thread; i++)
{
CPU_SET(cpu_mask[i], &coremask);
}
@@ -205,7 +205,7 @@ struct marsio_io *marsio_io_new(const char *app_symbol, const char *dev_symbol,
PACKET_IO_LOG_ERROR("unable to init marsio instance");
goto error_out;
}
handle->mr_dev = marsio_open_device(handle->mr_ins, dev_symbol, nr_threads, nr_threads);
handle->mr_dev = marsio_open_device(handle->mr_ins, dev_symbol, nr_worker_thread, nr_worker_thread);
if (handle->mr_dev == NULL)
{
PACKET_IO_LOG_ERROR("unable to open marsio device");

2
infra/packet_io/marsio_io.h
View File

@@ -8,7 +8,7 @@ extern "C"
#include "packet_io.h"
struct marsio_io;
struct marsio_io *marsio_io_new(const char *app_symbol, const char *dev_symbol, uint16_t *cpu_mask, uint16_t nr_threads);
struct marsio_io *marsio_io_new(const char *app_symbol, const char *dev_symbol, uint16_t *cpu_mask, uint16_t nr_worker_thread);
void marsio_io_free(struct marsio_io *handle);
int marsio_io_init(struct marsio_io *handle, uint16_t thr_idx);

4
infra/packet_io/packet_io.c
View File

@@ -22,11 +22,11 @@ struct packet_io *packet_io_new(struct packet_io_options *opts)
packet_io->mode = opts->mode;
if (opts->mode == PACKET_IO_MARSIO)
{
packet_io->marsio = marsio_io_new(opts->app_symbol, opts->dev_symbol, opts->cpu_mask, opts->nr_threads);
packet_io->marsio = marsio_io_new(opts->app_symbol, opts->dev_symbol, opts->cpu_mask, opts->nr_worker_thread);
}
else
{
packet_io->dumpfile = dumpfile_io_new(opts->dumpfile_path, packet_io->mode, opts->nr_threads);
packet_io->dumpfile = dumpfile_io_new(opts->dumpfile_path, packet_io->mode, opts->nr_worker_thread);
}
if (packet_io->marsio == NULL && packet_io->dumpfile == NULL)
{

2
infra/packet_io/packet_io.h
View File

@@ -64,7 +64,7 @@ struct packet_io_options
char app_symbol[64];
char dev_symbol[64];
uint16_t nr_threads;
uint16_t nr_worker_thread;
uint16_t cpu_mask[MAX_THREAD_NUM];
};

496
infra/session_manager/session_manager.c
View File

@@ -1,8 +1,10 @@
#include <time.h>
#include <stdlib.h>
#include <assert.h>
#include <errno.h>
#include "utils.h"
#include "toml.h"
#include "log_private.h"
#include "packet_helper.h"
#include "packet_filter.h"
@@ -16,6 +18,7 @@
#define SESSION_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "session", format, ##__VA_ARGS__)
#define SESSION_LOG_DEBUG(format, ...) STELLAR_LOG_DEBUG(__thread_local_logger, "session", format, ##__VA_ARGS__)
#define SESSION_LOG_INFO(format, ...) STELLAR_LOG_INFO(__thread_local_logger, "session", format, ##__VA_ARGS__)
struct session_manager
{
@@ -29,20 +32,21 @@ struct session_manager
struct session_filter *evicte_sess_filter;
struct session_manager_stat stat;
struct session_manager_options opts;
struct session_manager_config cfg;
/*
* only used for session_set_discard() or session_manager record_duplicated_packet(),
* because the function is called by pluin and has no time input.
*/
uint64_t now_ms;
uint64_t last_clean_expired_sess_ts;
session_id_generate_fn id_generator;
};
#define EVICTE_SESSION_BURST (RX_BURST_MAX)
/******************************************************************************
* Session Manager Stat
* session manager stat macro
******************************************************************************/
#define SESS_MGR_STAT_INC(stat, state, proto) \
@@ -103,136 +107,7 @@ struct session_manager
}
/******************************************************************************
* Session Manager Options
******************************************************************************/
static int check_options(const struct session_manager_options *opts)
{
if (opts == NULL)
{
SESSION_LOG_ERROR("invalid options");
return -1;
}
// max session number
if (opts->max_tcp_session_num < EVICTE_SESSION_BURST * 2)
{
SESSION_LOG_ERROR("invalid max_tcp_session_num: %lu, supported range: [%u, %lu]", opts->max_tcp_session_num, EVICTE_SESSION_BURST * 2, UINT64_MAX);
return -1;
}
if (opts->max_udp_session_num < EVICTE_SESSION_BURST * 2)
{
SESSION_LOG_ERROR("invalid max_udp_session_num: %lu, supported range: [%u, %lu]", opts->max_udp_session_num, EVICTE_SESSION_BURST * 2, UINT64_MAX);
return -1;
}
// session overload (skip)
// TCP timeout
if (opts->tcp_init_timeout < 1 || opts->tcp_init_timeout > 60000)
{
SESSION_LOG_ERROR("invalid tcp_init_timeout: %lu, supported range: [1, 60000]", opts->tcp_init_timeout);
return -1;
}
if (opts->tcp_handshake_timeout < 1 || opts->tcp_handshake_timeout > 60000)
{
SESSION_LOG_ERROR("invalid tcp_handshake_timeout: %lu, supported range: [1, 60000]", opts->tcp_handshake_timeout);
return -1;
}
if (opts->tcp_data_timeout < 1 || opts->tcp_data_timeout > 15999999000)
{
SESSION_LOG_ERROR("invalid tcp_data_timeout: %lu, supported range: [1, 15999999000]", opts->tcp_data_timeout);
return -1;
}
if (opts->tcp_half_closed_timeout < 1 || opts->tcp_half_closed_timeout > 604800000)
{
SESSION_LOG_ERROR("invalid tcp_half_closed_timeout: %lu, supported range: [1, 604800000]", opts->tcp_half_closed_timeout);
return -1;
}
if (opts->tcp_time_wait_timeout < 1 || opts->tcp_time_wait_timeout > 600000)
{
SESSION_LOG_ERROR("invalid tcp_time_wait_timeout: %lu, supported range: [1, 600000]", opts->tcp_time_wait_timeout);
return -1;
}
if (opts->tcp_discard_timeout < 1 || opts->tcp_discard_timeout > 15999999000)
{
SESSION_LOG_ERROR("invalid tcp_discard_timeout: %lu, supported range: [1, 15999999000]", opts->tcp_discard_timeout);
return -1;
}
if (opts->tcp_unverified_rst_timeout < 1 || opts->tcp_unverified_rst_timeout > 600000)
{
SESSION_LOG_ERROR("invalid tcp_unverified_rst_timeout: %lu, supported range: [1, 600000]", opts->tcp_unverified_rst_timeout);
return -1;
}
// UDP timeout
if (opts->udp_data_timeout < 1 || opts->udp_data_timeout > 15999999000)
{
SESSION_LOG_ERROR("invalid udp_data_timeout: %lu, supported range: [1, 15999999000]", opts->udp_data_timeout);
return -1;
}
// duplicate packet filter
if (opts->duplicated_packet_filter_enable)
{
if (opts->duplicated_packet_filter_capacity == 0)
{
// UINT32_MAX = 4294967295
SESSION_LOG_ERROR("invalid duplicated_packet_filter_capacity: %u, supported range: [1, 4294967295]", opts->duplicated_packet_filter_capacity);
return -1;
}
if (opts->duplicated_packet_filter_timeout < 1 || opts->duplicated_packet_filter_timeout > 60000)
{
SESSION_LOG_ERROR("invalid duplicated_packet_filter_timeout: %u, supported range: [1, 60000]", opts->duplicated_packet_filter_timeout);
return -1;
}
if (opts->duplicated_packet_filter_error_rate < 0.0 || opts->duplicated_packet_filter_error_rate > 1.0)
{
SESSION_LOG_ERROR("invalid duplicated_packet_filter_error_rate: %f, supported range: [0.0, 1.0]", opts->duplicated_packet_filter_error_rate);
return -1;
}
}
// evicted session filter
if (opts->evicted_session_filter_enable)
{
if (opts->evicted_session_filter_capacity == 0)
{
// UINT32_MAX = 4294967295
SESSION_LOG_ERROR("invalid evicted_session_filter_capacity: %u, supported range: [1, 4294967295]", opts->evicted_session_filter_capacity);
return -1;
}
if (opts->evicted_session_filter_timeout < 1 || opts->evicted_session_filter_timeout > 60000)
{
SESSION_LOG_ERROR("invalid evicted_session_filter_timeout: %u, supported range: [1, 60000]", opts->evicted_session_filter_timeout);
return -1;
}
if (opts->evicted_session_filter_error_rate < 0.0 || opts->evicted_session_filter_error_rate > 1.0)
{
SESSION_LOG_ERROR("invalid evicted_session_filter_error_rate: %f, supported range: [0.0, 1.0]", opts->evicted_session_filter_error_rate);
return -1;
}
}
// TCP reassembly
if (opts->tcp_reassembly_enable)
{
if (opts->tcp_reassembly_max_timeout < 1 || opts->tcp_reassembly_max_timeout > 60000)
{
SESSION_LOG_ERROR("invalid tcp_reassembly_max_timeout: %u, supported range: [1, 60000]", opts->tcp_reassembly_max_timeout);
return -1;
}
if (opts->tcp_reassembly_max_segments < 2 || opts->tcp_reassembly_max_segments > 4096)
{
SESSION_LOG_ERROR("invalid tcp_reassembly_max_segments: %u, supported range: [2, 4096]", opts->tcp_reassembly_max_segments);
return -1;
}
}
return 0;
}
/******************************************************************************
* TCP
* TCP utils
******************************************************************************/
static void tcp_clean(struct session_manager *mgr, struct session *sess)
@@ -266,13 +141,13 @@ static void tcp_clean(struct session_manager *mgr, struct session *sess)
static int tcp_init(struct session_manager *mgr, struct session *sess)
{
if (!mgr->opts.tcp_reassembly_enable)
if (!mgr->cfg.tcp_reassembly_enable)
{
return 0;
}
sess->tcp_halfs[FLOW_DIRECTION_C2S].assembler = tcp_reassembly_new(mgr->opts.tcp_reassembly_max_timeout, mgr->opts.tcp_reassembly_max_segments);
sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler = tcp_reassembly_new(mgr->opts.tcp_reassembly_max_timeout, mgr->opts.tcp_reassembly_max_segments);
sess->tcp_halfs[FLOW_DIRECTION_C2S].assembler = tcp_reassembly_new(mgr->cfg.tcp_reassembly_max_timeout_ms, mgr->cfg.tcp_reassembly_max_segments);
sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler = tcp_reassembly_new(mgr->cfg.tcp_reassembly_max_timeout_ms, mgr->cfg.tcp_reassembly_max_segments);
if (sess->tcp_halfs[FLOW_DIRECTION_C2S].assembler == NULL || sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler == NULL)
{
tcp_clean(mgr, sess);
@@ -305,7 +180,7 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
half->ack = tcp_hdr_get_ack(hdr);
half->len = tcp_layer->pld_len;
if (!mgr->opts.tcp_reassembly_enable)
if (!mgr->cfg.tcp_reassembly_enable)
{
if (len)
{
@@ -415,7 +290,7 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
}
/******************************************************************************
* Session Direction
* session direction identify
******************************************************************************/
static enum flow_direction identify_direction_by_port(uint16_t src_port, uint16_t dst_port)
@@ -449,13 +324,13 @@ static enum flow_direction identify_direction_by_history(const struct session *s
}
/******************************************************************************
* Session Filter
* session filter bypass utils
******************************************************************************/
// on new session
static int tcp_overload_bypass(struct session_manager *mgr, const struct tuple6 *key)
{
if (key->ip_proto == IPPROTO_TCP && mgr->stat.tcp_sess_used >= mgr->opts.max_tcp_session_num)
if (key->ip_proto == IPPROTO_TCP && mgr->stat.tcp_sess_used >= mgr->cfg.max_tcp_session_num)
{
mgr->stat.tcp_pkts_bypass_table_full++;
return 1;
@@ -465,7 +340,7 @@ static int tcp_overload_bypass(struct session_manager *mgr, const struct tuple6
static int udp_overload_bypass(struct session_manager *mgr, const struct tuple6 *key)
{
if (key->ip_proto == IPPROTO_UDP && mgr->stat.udp_sess_used >= mgr->opts.max_udp_session_num)
if (key->ip_proto == IPPROTO_UDP && mgr->stat.udp_sess_used >= mgr->cfg.max_udp_session_num)
{
mgr->stat.udp_pkts_bypass_table_full++;
return 1;
@@ -475,7 +350,7 @@ static int udp_overload_bypass(struct session_manager *mgr, const struct tuple6
static int evicted_session_bypass(struct session_manager *mgr, const struct tuple6 *key)
{
if (mgr->opts.evicted_session_filter_enable && session_filter_lookup(mgr->evicte_sess_filter, key, mgr->now_ms))
if (mgr->cfg.evicted_session_filter_enable && session_filter_lookup(mgr->evicte_sess_filter, key, mgr->now_ms))
{
mgr->stat.udp_pkts_bypass_session_evicted++;
return 1;
@@ -487,7 +362,7 @@ static int evicted_session_bypass(struct session_manager *mgr, const struct tupl
// on update session
static int duplicated_packet_bypass(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key)
{
if (mgr->opts.duplicated_packet_filter_enable == 0)
if (mgr->cfg.duplicated_packet_filter_enable == 0)
{
return 0;
}
@@ -528,7 +403,7 @@ static int duplicated_packet_bypass(struct session_manager *mgr, struct session
}
/******************************************************************************
* Session Manager
* session manager utils
******************************************************************************/
static void session_update(struct session_manager *mgr, struct session *sess, enum session_state next_state, const struct packet *pkt, const struct tuple6 *key, enum flow_direction dir)
@@ -642,7 +517,7 @@ static void session_manager_evicte_session(struct session_manager *mgr, struct s
case SESSION_TYPE_UDP:
SESSION_LOG_DEBUG("evicte udp old session: %lu", session_get_id(sess));
session_table_del(mgr->udp_sess_table, sess);
if (mgr->opts.evicted_session_filter_enable)
if (mgr->cfg.evicted_session_filter_enable)
{
session_filter_add(mgr->evicte_sess_filter, session_get_tuple6(sess), mgr->now_ms);
}
@@ -699,7 +574,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
}
// tcp table full evict old session
if (mgr->opts.tcp_overload_evict_old_sess && mgr->stat.tcp_sess_used >= mgr->opts.max_tcp_session_num - EVICTE_SESSION_BURST)
if (mgr->cfg.tcp_overload_evict_old_sess && mgr->stat.tcp_sess_used >= mgr->cfg.max_tcp_session_num - EVICTE_SESSION_BURST)
{
struct session *evic_sess = session_table_find_lru(mgr->tcp_sess_table);
session_manager_evicte_session(mgr, evic_sess, LRU_EVICT);
@@ -728,11 +603,11 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
}
tcp_update(mgr, sess, dir, tcp_layer);
uint64_t timeout = (flags & TH_ACK) ? mgr->opts.tcp_handshake_timeout : mgr->opts.tcp_init_timeout;
uint64_t timeout = (flags & TH_ACK) ? mgr->cfg.tcp_handshake_timeout_ms : mgr->cfg.tcp_init_timeout_ms;
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + timeout);
session_table_add(mgr->tcp_sess_table, sess);
if (mgr->opts.duplicated_packet_filter_enable)
if (mgr->cfg.duplicated_packet_filter_enable)
{
packet_filter_add(mgr->dup_pkt_filter, pkt, mgr->now_ms);
}
@@ -747,7 +622,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
static struct session *session_manager_new_udp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key)
{
// udp table full evict old session
if (mgr->opts.udp_overload_evict_old_sess && mgr->stat.udp_sess_used >= mgr->opts.max_udp_session_num - EVICTE_SESSION_BURST)
if (mgr->cfg.udp_overload_evict_old_sess && mgr->stat.udp_sess_used >= mgr->cfg.max_udp_session_num - EVICTE_SESSION_BURST)
{
struct session *evic_sess = session_table_find_lru(mgr->udp_sess_table);
session_manager_evicte_session(mgr, evic_sess, LRU_EVICT);
@@ -768,7 +643,7 @@ static struct session *session_manager_new_udp_session(struct session_manager *m
session_update(mgr, sess, next_state, pkt, key, dir);
session_transition_log(sess, SESSION_STATE_INIT, next_state, UDP_DATA);
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->opts.udp_data_timeout);
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->cfg.udp_data_timeout_ms);
session_table_add(mgr->udp_sess_table, sess);
SESS_MGR_STAT_INC(&mgr->stat, next_state, udp);
@@ -823,34 +698,34 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
case SESSION_STATE_OPENING:
if (flags & TH_SYN)
{
timeout = (flags & TH_ACK) ? mgr->opts.tcp_handshake_timeout : mgr->opts.tcp_init_timeout;
timeout = (flags & TH_ACK) ? mgr->cfg.tcp_handshake_timeout_ms : mgr->cfg.tcp_init_timeout_ms;
}
else
{
timeout = mgr->opts.tcp_data_timeout;
timeout = mgr->cfg.tcp_data_timeout_ms;
}
break;
case SESSION_STATE_ACTIVE:
timeout = mgr->opts.tcp_data_timeout;
timeout = mgr->cfg.tcp_data_timeout_ms;
break;
case SESSION_STATE_CLOSING:
if (flags & TH_FIN)
{
timeout = (peer->history & TH_FIN) ? mgr->opts.tcp_time_wait_timeout : mgr->opts.tcp_half_closed_timeout;
timeout = (peer->history & TH_FIN) ? mgr->cfg.tcp_time_wait_timeout_ms : mgr->cfg.tcp_half_closed_timeout_ms;
}
else if (flags & TH_RST)
{
// if fin is received, the expected sequence number should be increased by 1
uint32_t expected = (peer->history & TH_FIN) ? peer->ack + 1 : peer->ack;
timeout = (expected == curr->seq) ? mgr->opts.tcp_time_wait_timeout : mgr->opts.tcp_unverified_rst_timeout;
timeout = (expected == curr->seq) ? mgr->cfg.tcp_time_wait_timeout_ms : mgr->cfg.tcp_unverified_rst_timeout_ms;
}
else
{
timeout = mgr->opts.tcp_data_timeout;
timeout = mgr->cfg.tcp_data_timeout_ms;
}
break;
case SESSION_STATE_DISCARD:
timeout = mgr->opts.tcp_discard_timeout;
timeout = mgr->cfg.tcp_discard_timeout_ms;
break;
default:
assert(0);
@@ -873,11 +748,11 @@ static int session_manager_update_udp_session(struct session_manager *mgr, struc
if (session_get_current_state(sess) == SESSION_STATE_DISCARD)
{
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->opts.udp_discard_timeout);
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->cfg.udp_discard_timeout_ms);
}
else
{
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->opts.udp_data_timeout);
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->cfg.udp_data_timeout_ms);
}
SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, udp);
@@ -885,25 +760,230 @@ static int session_manager_update_udp_session(struct session_manager *mgr, struc
return 0;
}
static inline uint8_t ipv4_in_range(const struct in_addr *addr, const struct in_addr *start, const struct in_addr *end)
{
return (memcmp(addr, start, sizeof(struct in_addr)) >= 0 && memcmp(addr, end, sizeof(struct in_addr)) <= 0);
}
static inline uint8_t ipv6_in_range(const struct in6_addr *addr, const struct in6_addr *start, const struct in6_addr *end)
{
return (memcmp(addr, start, sizeof(struct in6_addr)) >= 0 && memcmp(addr, end, sizeof(struct in6_addr)) <= 0);
}
/******************************************************************************
* Public API
* session manager public API
******************************************************************************/
struct session_manager *session_manager_new(struct session_manager_options *opts, uint64_t now_ms)
#define PARSE_AND_CHECK_NUM(table, key, val, min, max) \
do \
{ \
const char *ptr = toml_raw_in(table, (key)); \
if (ptr == NULL) \
{ \
SESSION_LOG_ERROR("config file missing session_manager.%s", (key)); \
goto error_out; \
} \
(val) = atoll(ptr); \
if ((val) < (min) || (val) > (max)) \
{ \
SESSION_LOG_ERROR("invalid session_manager.%s: %lu, supported range: [%lu, %lu]", (key), (val), (min), (max)); \
goto error_out; \
} \
} while (0)
#define PARSE_AND_CHECK_DOUBLE(table, key, val, min, max) \
do \
{ \
const char *ptr = toml_raw_in(table, (key)); \
if (ptr == NULL) \
{ \
SESSION_LOG_ERROR("config file missing session_manager.%s", (key)); \
goto error_out; \
} \
(val) = atof(ptr); \
if ((val) < (min) || (val) > (max)) \
{ \
SESSION_LOG_ERROR("invalid session_manager.%s: %lu, supported range: [%f, %f]", (key), (val), (min), (max)); \
goto error_out; \
} \
} while (0)
int session_manager_config_load(struct session_manager_config *cfg, const char *toml_file)
{
if (check_options(opts) == -1)
int ret = -1;
char errbuf[200];
FILE *fp = NULL;
toml_table_t *root = NULL;
toml_table_t *table = NULL;
uint64_t zero = 0; // make compiler happy
fp = fopen(toml_file, "r");
if (fp == NULL)
{
SESSION_LOG_ERROR("config file %s open failed, %s", toml_file, strerror(errno));
goto error_out;
}
root = toml_parse_file(fp, errbuf, sizeof(errbuf));
if (root == NULL)
{
SESSION_LOG_ERROR("config file %s parse failed, %s", toml_file, errbuf);
goto error_out;
}
table = toml_table_in(root, "session_manager");
if (table == NULL)
{
SESSION_LOG_ERROR("config file %s missing session_manager", toml_file);
goto error_out;
}
// max session number
PARSE_AND_CHECK_NUM(table, "max_tcp_session_num", cfg->max_tcp_session_num, EVICTE_SESSION_BURST * 2, UINT64_MAX);
PARSE_AND_CHECK_NUM(table, "max_udp_session_num", cfg->max_udp_session_num, EVICTE_SESSION_BURST * 2, UINT64_MAX);
// session overload
PARSE_AND_CHECK_NUM(table, "tcp_overload_evict_old_sess", cfg->tcp_overload_evict_old_sess, zero, 1);
PARSE_AND_CHECK_NUM(table, "udp_overload_evict_old_sess", cfg->udp_overload_evict_old_sess, zero, 1);
// TCP timeout
PARSE_AND_CHECK_NUM(table, "tcp_init_timeout_ms", cfg->tcp_init_timeout_ms, 1, 60000);
PARSE_AND_CHECK_NUM(table, "tcp_handshake_timeout_ms", cfg->tcp_handshake_timeout_ms, 1, 60000);
PARSE_AND_CHECK_NUM(table, "tcp_data_timeout_ms", cfg->tcp_data_timeout_ms, 1, 15999999000);
PARSE_AND_CHECK_NUM(table, "tcp_half_closed_timeout_ms", cfg->tcp_half_closed_timeout_ms, 1, 604800000);
PARSE_AND_CHECK_NUM(table, "tcp_time_wait_timeout_ms", cfg->tcp_time_wait_timeout_ms, 1, 60000);
PARSE_AND_CHECK_NUM(table, "tcp_discard_timeout_ms", cfg->tcp_discard_timeout_ms, 1, 15999999000);
PARSE_AND_CHECK_NUM(table, "tcp_unverified_rst_timeout_ms", cfg->tcp_unverified_rst_timeout_ms, 1, 60000);
// UDP timeout
PARSE_AND_CHECK_NUM(table, "udp_data_timeout_ms", cfg->udp_data_timeout_ms, 1, 15999999000);
PARSE_AND_CHECK_NUM(table, "udp_discard_timeout_ms", cfg->udp_discard_timeout_ms, 1, 15999999000);
// limit
PARSE_AND_CHECK_NUM(table, "session_expire_polling_interval_ms", cfg->session_expire_polling_interval_ms, zero, 60000);
PARSE_AND_CHECK_NUM(table, "session_expire_polling_limit", cfg->session_expire_polling_limit, 1, 1024);
// duplicated packet filter
PARSE_AND_CHECK_NUM(table, "duplicated_packet_filter_enable", cfg->duplicated_packet_filter_enable, zero, 1);
PARSE_AND_CHECK_NUM(table, "duplicated_packet_filter_capacity", cfg->duplicated_packet_filter_capacity, 1, 4294967295);
PARSE_AND_CHECK_NUM(table, "duplicated_packet_filter_timeout_ms", cfg->duplicated_packet_filter_timeout_ms, 1, 60000);
PARSE_AND_CHECK_DOUBLE(table, "duplicated_packet_filter_error_rate", cfg->duplicated_packet_filter_error_rate, 0.0, 1.0);
// eviction session filter
PARSE_AND_CHECK_NUM(table, "evicted_session_filter_enable", cfg->evicted_session_filter_enable, zero, 1);
PARSE_AND_CHECK_NUM(table, "evicted_session_filter_capacity", cfg->evicted_session_filter_capacity, 1, 4294967295);
PARSE_AND_CHECK_NUM(table, "evicted_session_filter_timeout_ms", cfg->evicted_session_filter_timeout_ms, 1, 60000);
PARSE_AND_CHECK_DOUBLE(table, "evicted_session_filter_error_rate", cfg->evicted_session_filter_error_rate, 0.0, 1.0);
// TCP reassembly
PARSE_AND_CHECK_NUM(table, "tcp_reassembly_enable", cfg->tcp_reassembly_enable, zero, 1);
PARSE_AND_CHECK_NUM(table, "tcp_reassembly_max_timeout_ms", cfg->tcp_reassembly_max_timeout_ms, 1, 60000);
PARSE_AND_CHECK_NUM(table, "tcp_reassembly_max_segments", cfg->tcp_reassembly_max_segments, 1, 512);
ret = 0;
error_out:
if (root)
{
toml_free(root);
}
if (fp)
{
fclose(fp);
}
return ret;
}
struct session_manager_config *session_manager_config_new(const char *toml_file)
{
if (toml_file == NULL)
{
return NULL;
}
struct session_manager_config *cfg = (struct session_manager_config *)calloc(1, sizeof(struct session_manager_config));
if (cfg == NULL)
{
return NULL;
}
if (session_manager_config_load(cfg, toml_file) == -1)
{
session_manager_config_free(cfg);
return NULL;
}
return cfg;
}
void session_manager_config_free(struct session_manager_config *cfg)
{
if (cfg)
{
free(cfg);
cfg = NULL;
}
}
void session_manager_config_print(struct session_manager_config *cfg)
{
if (cfg)
{
// max session number
SESSION_LOG_INFO("session_manager.max_tcp_session_num : %lu", cfg->max_tcp_session_num);
SESSION_LOG_INFO("session_manager.max_udp_session_num : %lu", cfg->max_udp_session_num);
// session overload
SESSION_LOG_INFO("session_manager.tcp_overload_evict_old_sess : %d", cfg->tcp_overload_evict_old_sess);
SESSION_LOG_INFO("session_manager.udp_overload_evict_old_sess : %d", cfg->udp_overload_evict_old_sess);
// TCP timeout
SESSION_LOG_INFO("session_manager.tcp_init_timeout_ms : %lu", cfg->tcp_init_timeout_ms);
SESSION_LOG_INFO("session_manager.tcp_handshake_timeout_ms : %lu", cfg->tcp_handshake_timeout_ms);
SESSION_LOG_INFO("session_manager.tcp_data_timeout_ms : %lu", cfg->tcp_data_timeout_ms);
SESSION_LOG_INFO("session_manager.tcp_half_closed_timeout_ms : %lu", cfg->tcp_half_closed_timeout_ms);
SESSION_LOG_INFO("session_manager.tcp_time_wait_timeout_ms : %lu", cfg->tcp_time_wait_timeout_ms);
SESSION_LOG_INFO("session_manager.tcp_discard_timeout_ms : %lu", cfg->tcp_discard_timeout_ms);
SESSION_LOG_INFO("session_manager.tcp_unverified_rst_timeout_ms : %lu", cfg->tcp_unverified_rst_timeout_ms);
// UDP timeout
SESSION_LOG_INFO("session_manager.udp_data_timeout_ms : %lu", cfg->udp_data_timeout_ms);
SESSION_LOG_INFO("session_manager.udp_discard_timeout_ms : %lu", cfg->udp_discard_timeout_ms);
// limit
SESSION_LOG_INFO("session_manager.session_expire_polling_interval_ms : %lu", cfg->session_expire_polling_interval_ms);
SESSION_LOG_INFO("session_manager.session_expire_polling_limit : %lu", cfg->session_expire_polling_limit);
// duplicated packet filter
SESSION_LOG_INFO("session_manager.duplicated_packet_filter_enable : %d", cfg->duplicated_packet_filter_enable);
SESSION_LOG_INFO("session_manager.duplicated_packet_filter_capacity : %lu", cfg->duplicated_packet_filter_capacity);
SESSION_LOG_INFO("session_manager.duplicated_packet_filter_timeout_ms : %lu", cfg->duplicated_packet_filter_timeout_ms);
SESSION_LOG_INFO("session_manager.duplicated_packet_filter_error_rate : %f", cfg->duplicated_packet_filter_error_rate);
// eviction session filter
SESSION_LOG_INFO("session_manager.evicted_session_filter_enable : %d", cfg->evicted_session_filter_enable);
SESSION_LOG_INFO("session_manager.evicted_session_filter_capacity : %lu", cfg->evicted_session_filter_capacity);
SESSION_LOG_INFO("session_manager.evicted_session_filter_timeout_ms : %lu", cfg->evicted_session_filter_timeout_ms);
SESSION_LOG_INFO("session_manager.evicted_session_filter_error_rate : %f", cfg->evicted_session_filter_error_rate);
// TCP reassembly
SESSION_LOG_INFO("session_manager.tcp_reassembly_enable : %d", cfg->tcp_reassembly_enable);
SESSION_LOG_INFO("session_manager.tcp_reassembly_max_timeout_ms : %lu", cfg->tcp_reassembly_max_timeout_ms);
SESSION_LOG_INFO("session_manager.tcp_reassembly_max_segments : %lu", cfg->tcp_reassembly_max_segments);
}
}
struct session_manager *session_manager_new(const struct session_manager_config *cfg, uint64_t now_ms)
{
struct session_manager *mgr = (struct session_manager *)calloc(1, sizeof(struct session_manager));
if (mgr == NULL)
{
return NULL;
}
memcpy(&mgr->opts, opts, sizeof(struct session_manager_options));
memcpy(&mgr->cfg, cfg, sizeof(struct session_manager_config));
mgr->sess_pool = session_pool_new(mgr->opts.max_tcp_session_num + mgr->opts.max_udp_session_num);
mgr->sess_pool = session_pool_new(mgr->cfg.max_tcp_session_num + mgr->cfg.max_udp_session_num);
mgr->tcp_sess_table = session_table_new();
mgr->udp_sess_table = session_table_new();
mgr->sess_timer = session_timer_new(now_ms);
@@ -911,21 +991,21 @@ struct session_manager *session_manager_new(struct session_manager_options *opts
{
goto error;
}
if (mgr->opts.evicted_session_filter_enable)
if (mgr->cfg.evicted_session_filter_enable)
{
mgr->evicte_sess_filter = session_filter_new(mgr->opts.evicted_session_filter_capacity,
mgr->opts.evicted_session_filter_timeout,
mgr->opts.evicted_session_filter_error_rate, now_ms);
mgr->evicte_sess_filter = session_filter_new(mgr->cfg.evicted_session_filter_capacity,
mgr->cfg.evicted_session_filter_timeout_ms,
mgr->cfg.evicted_session_filter_error_rate, now_ms);
if (mgr->evicte_sess_filter == NULL)
{
goto error;
}
}
if (mgr->opts.duplicated_packet_filter_enable)
if (mgr->cfg.duplicated_packet_filter_enable)
{
mgr->dup_pkt_filter = packet_filter_new(mgr->opts.duplicated_packet_filter_capacity,
mgr->opts.duplicated_packet_filter_timeout,
mgr->opts.duplicated_packet_filter_error_rate, now_ms);
mgr->dup_pkt_filter = packet_filter_new(mgr->cfg.duplicated_packet_filter_capacity,
mgr->cfg.duplicated_packet_filter_timeout_ms,
mgr->cfg.duplicated_packet_filter_error_rate, now_ms);
if (mgr->dup_pkt_filter == NULL)
{
goto error;
@@ -935,6 +1015,7 @@ struct session_manager *session_manager_new(struct session_manager_options *opts
INIT_LIST_HEAD(&mgr->evicte_queue);
session_transition_init();
mgr->now_ms = now_ms;
mgr->last_clean_expired_sess_ts = now_ms;
return mgr;
@@ -965,11 +1046,11 @@ void session_manager_free(struct session_manager *mgr)
{
session_manager_free_session(mgr, sess);
}
if (mgr->opts.evicted_session_filter_enable)
if (mgr->cfg.evicted_session_filter_enable)
{
session_filter_free(mgr->evicte_sess_filter);
}
if (mgr->opts.duplicated_packet_filter_enable)
if (mgr->cfg.duplicated_packet_filter_enable)
{
packet_filter_free(mgr->dup_pkt_filter);
}
@@ -989,7 +1070,7 @@ void session_manager_set_session_id_generator(struct session_manager *mgr, sessi
void session_manager_record_duplicated_packet(struct session_manager *mgr, const struct packet *pkt)
{
if (mgr->opts.duplicated_packet_filter_enable)
if (mgr->cfg.duplicated_packet_filter_enable)
{
packet_filter_add(mgr->dup_pkt_filter, pkt, mgr->now_ms);
}
@@ -1174,10 +1255,10 @@ struct session *session_manager_get_expired_session(struct session_manager *mgr,
switch (session_get_type(sess))
{
case SESSION_TYPE_TCP:
session_timer_update(mgr->sess_timer, sess, now_ms + mgr->opts.tcp_data_timeout);
session_timer_update(mgr->sess_timer, sess, now_ms + mgr->cfg.tcp_data_timeout_ms);
break;
case SESSION_TYPE_UDP:
session_timer_update(mgr->sess_timer, sess, now_ms + mgr->opts.udp_data_timeout);
session_timer_update(mgr->sess_timer, sess, now_ms + mgr->cfg.udp_data_timeout_ms);
break;
default:
assert(0);
@@ -1204,6 +1285,55 @@ struct session *session_manager_get_evicted_session(struct session_manager *mgr)
}
}
// array_size at least EVICTE_SESSION_BURST, suggest 2 * EVICTE_SESSION_BURST
uint64_t session_manager_clean_session(struct session_manager *mgr, uint64_t now_ms, struct session *cleaned_sess[], uint64_t array_size)
{
mgr->now_ms = now_ms;
struct session *sess = NULL;
uint64_t cleaned_sess_num = 0;
uint64_t expired_sess_num = 0;
uint8_t expired_sess_canbe_clean = 0;
if (now_ms - mgr->last_clean_expired_sess_ts >= mgr->cfg.session_expire_polling_interval_ms)
{
expired_sess_canbe_clean = 1;
}
for (uint64_t i = 0; i < array_size; i++)
{
// frist clean evicted session
sess = session_manager_get_evicted_session(mgr);
if (sess)
{
cleaned_sess[cleaned_sess_num++] = sess;
}
// then clean expired session
else
{
if (expired_sess_canbe_clean && expired_sess_num < mgr->cfg.session_expire_polling_limit)
{
mgr->last_clean_expired_sess_ts = now_ms;
sess = session_manager_get_expired_session(mgr, now_ms);
if (sess)
{
cleaned_sess[cleaned_sess_num++] = sess;
expired_sess_num++;
}
else
{
break;
}
}
else
{
break;
}
}
}
return cleaned_sess_num;
}
uint64_t session_manager_get_expire_interval(struct session_manager *mgr)
{
return session_timer_next_expire_interval(mgr->sess_timer);
@@ -1226,11 +1356,11 @@ void session_set_discard(struct session *sess)
switch (type)
{
case SESSION_TYPE_TCP:
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->opts.tcp_discard_timeout);
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->cfg.tcp_discard_timeout_ms);
SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, tcp);
break;
case SESSION_TYPE_UDP:
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->opts.udp_discard_timeout);
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->cfg.udp_discard_timeout_ms);
SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, udp);
break;
default:
@@ -1239,16 +1369,6 @@ void session_set_discard(struct session *sess)
}
}
static inline uint8_t ipv4_in_range(const struct in_addr *addr, const struct in_addr *start, const struct in_addr *end)
{
return (memcmp(addr, start, sizeof(struct in_addr)) >= 0 && memcmp(addr, end, sizeof(struct in_addr)) <= 0);
}
static inline uint8_t ipv6_in_range(const struct in6_addr *addr, const struct in6_addr *start, const struct in6_addr *end)
{
return (memcmp(addr, start, sizeof(struct in6_addr)) >= 0 && memcmp(addr, end, sizeof(struct in6_addr)) <= 0);
}
uint64_t session_manager_scan(const struct session_manager *mgr, const struct session_scan_opts *opts, uint64_t mached_sess_ids[], uint64_t array_size)
{
uint64_t capacity = 0;

47
infra/session_manager/session_manager.h
View File

@@ -8,7 +8,7 @@ extern "C"
#include "tuple.h"
#include "stellar/session.h"
struct session_manager_options
struct session_manager_config
{
// max session number
uint64_t max_tcp_session_num;
@@ -19,33 +19,37 @@ struct session_manager_options
uint8_t udp_overload_evict_old_sess; // 1: evict old session, 0: bypass new session
// TCP timeout
uint64_t tcp_init_timeout; // range: [1, 60000] (ms)
uint64_t tcp_handshake_timeout; // range: [1, 60000] (ms)
uint64_t tcp_data_timeout; // range: [1, 15999999000] (ms)
uint64_t tcp_half_closed_timeout; // range: [1, 604800000] (ms)
uint64_t tcp_time_wait_timeout; // range: [1, 600000] (ms)
uint64_t tcp_discard_timeout; // range: [1, 15999999000] (ms)
uint64_t tcp_unverified_rst_timeout; // range: [1, 600000] (ms)
uint64_t tcp_init_timeout_ms; // range: [1, 60000] (ms)
uint64_t tcp_handshake_timeout_ms; // range: [1, 60000] (ms)
uint64_t tcp_data_timeout_ms; // range: [1, 15999999000] (ms)
uint64_t tcp_half_closed_timeout_ms; // range: [1, 604800000] (ms)
uint64_t tcp_time_wait_timeout_ms; // range: [1, 600000] (ms)
uint64_t tcp_discard_timeout_ms; // range: [1, 15999999000] (ms)
uint64_t tcp_unverified_rst_timeout_ms; // range: [1, 600000] (ms)
// UDP timeout
uint64_t udp_data_timeout; // range: [1, 15999999000] (ms)
uint64_t udp_discard_timeout; // range: [1, 15999999000] (ms)
uint64_t udp_data_timeout_ms; // range: [1, 15999999000] (ms)
uint64_t udp_discard_timeout_ms; // range: [1, 15999999000] (ms)
// limit
uint64_t session_expire_polling_interval_ms; // range: [0, 60000] (ms)
uint64_t session_expire_polling_limit; // range: [1, 1024]
// duplicate packet filter
uint8_t duplicated_packet_filter_enable;
uint32_t duplicated_packet_filter_capacity; // range: [1, 4294967295]
uint32_t duplicated_packet_filter_timeout; // range: [1, 60000] (ms)
double duplicated_packet_filter_error_rate; // range: [0.0, 1.0]
uint32_t duplicated_packet_filter_capacity; // range: [1, 4294967295]
uint32_t duplicated_packet_filter_timeout_ms; // range: [1, 60000] (ms)
double duplicated_packet_filter_error_rate; // range: [0.0, 1.0]
// evicted session filter
uint8_t evicted_session_filter_enable;
uint32_t evicted_session_filter_capacity; // range: [1, 4294967295]
uint32_t evicted_session_filter_timeout; // range: [1, 60000] (ms)
double evicted_session_filter_error_rate; // range: [0.0, 1.0]
uint32_t evicted_session_filter_capacity; // range: [1, 4294967295]
uint32_t evicted_session_filter_timeout_ms; // range: [1, 60000] (ms)
double evicted_session_filter_error_rate; // range: [0.0, 1.0]
// TCP reassembly
uint8_t tcp_reassembly_enable;
uint32_t tcp_reassembly_max_timeout; // range: [1, 60000] (ms)
uint32_t tcp_reassembly_max_segments; // range: [2, 512]
uint32_t tcp_reassembly_max_timeout_ms; // range: [1, 60000] (ms)
uint32_t tcp_reassembly_max_segments; // range: [2, 512]
};
struct __attribute__((aligned(64))) session_manager_stat
@@ -129,8 +133,12 @@ struct session_scan_opts
uint64_t last_pkt_time_ms[2];
};
struct session_manager_config *session_manager_config_new(const char *toml_file);
void session_manager_config_free(struct session_manager_config *cfg);
void session_manager_config_print(struct session_manager_config *cfg);
struct session_manager;
struct session_manager *session_manager_new(struct session_manager_options *opts, uint64_t now_ms);
struct session_manager *session_manager_new(const struct session_manager_config *cfg, uint64_t now_ms);
void session_manager_free(struct session_manager *mgr);
typedef uint64_t (*session_id_generate_fn)(uint64_t now_ms);
@@ -147,6 +155,7 @@ int session_manager_update_session(struct session_manager *mgr, struct session *
// return session need free by session_manager_free_session()
struct session *session_manager_get_expired_session(struct session_manager *mgr, uint64_t now_ms);
struct session *session_manager_get_evicted_session(struct session_manager *mgr);
uint64_t session_manager_clean_session(struct session_manager *mgr, uint64_t now_ms, struct session *cleaned_sess[], uint64_t array_size);
// return 0: have already timeout session
// return >0: next expire interval

36
infra/session_manager/test/gtest_case_tcp_fast_open.cpp
View File

@@ -6,7 +6,7 @@
#include "session_private.h"
#include "session_manager.h"
struct session_manager_options opts = {
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
@@ -16,33 +16,37 @@ struct session_manager_options opts = {
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout = 1,
.tcp_handshake_timeout = 2,
.tcp_data_timeout = 3,
.tcp_half_closed_timeout = 4,
.tcp_time_wait_timeout = 5,
.tcp_discard_timeout = 6,
.tcp_unverified_rst_timeout = 7,
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout = 8,
.udp_discard_timeout = 0,
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
@@ -312,7 +316,7 @@ TEST(CASE, TCP_FAST_OPEN)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -402,8 +406,8 @@ TEST(CASE, TCP_FAST_OPEN)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_init_timeout) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + opts.tcp_init_timeout + opts.tcp_data_timeout); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms + cfg.tcp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);

52
infra/session_manager/test/gtest_filter_tcp_dupkt.cpp
View File

@@ -6,7 +6,7 @@
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
@@ -16,33 +16,37 @@ struct session_manager_options opts = {
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout = 1,
.tcp_handshake_timeout = 2,
.tcp_data_timeout = 3,
.tcp_half_closed_timeout = 4,
.tcp_time_wait_timeout = 5,
.tcp_discard_timeout = 6,
.tcp_unverified_rst_timeout = 7,
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout = 8,
.udp_discard_timeout = 0,
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
@@ -68,7 +72,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -135,7 +139,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -203,7 +207,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
struct session_manager_stat *stat = NULL;
char syn_retransmission[1500] = {0};
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -286,11 +290,11 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
struct session_manager_options _opts;
memcpy(&_opts, &opts, sizeof(struct session_manager_options));
_opts.duplicated_packet_filter_enable = 0;
struct session_manager_config _cfg;
memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
_cfg.duplicated_packet_filter_enable = 0;
mgr = session_manager_new(&_opts, 1);
mgr = session_manager_new(&_cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -337,11 +341,11 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
struct session_manager_options _opts;
memcpy(&_opts, &opts, sizeof(struct session_manager_options));
_opts.duplicated_packet_filter_enable = 0;
struct session_manager_config _cfg;
memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
_cfg.duplicated_packet_filter_enable = 0;
mgr = session_manager_new(&_opts, 1);
mgr = session_manager_new(&_cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);

60
infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp
View File

@@ -7,7 +7,7 @@
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = RX_BURST_MAX * 2,
.max_udp_session_num = RX_BURST_MAX * 2,
@@ -17,33 +17,37 @@ struct session_manager_options opts = {
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout = 1,
.tcp_handshake_timeout = 2,
.tcp_data_timeout = 3,
.tcp_half_closed_timeout = 4,
.tcp_time_wait_timeout = 5,
.tcp_discard_timeout = 6,
.tcp_unverified_rst_timeout = 7,
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout = 8,
.udp_discard_timeout = 0,
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
@@ -68,7 +72,7 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -79,15 +83,15 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
printf("<= Packet Parse: done\n\n");
// new session
for (uint32_t i = 0; i < opts.max_tcp_session_num; i++)
for (uint32_t i = 0; i < cfg.max_tcp_session_num; i++)
{
packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
}
printf("=> Session Manager: after add %lu new sessions\n", opts.max_tcp_session_num);
printf("=> Session Manager: after add %lu new sessions\n", cfg.max_tcp_session_num);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess_used == opts.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess_used == cfg.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0);
@@ -106,11 +110,11 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
struct packet pkt;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
struct session_manager_options _opts;
memcpy(&_opts, &opts, sizeof(struct session_manager_options));
_opts.tcp_overload_evict_old_sess = 0;
struct session_manager_config _cfg;
memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
_cfg.tcp_overload_evict_old_sess = 0;
mgr = session_manager_new(&_opts, 1);
mgr = session_manager_new(&_cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -121,16 +125,16 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
printf("<= Packet Parse: done\n\n");
// new session
for (uint32_t i = 0; i < opts.max_tcp_session_num; i++)
for (uint32_t i = 0; i < cfg.max_tcp_session_num; i++)
{
packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
}
printf("=> Session Manager: after add %lu new sessions\n", opts.max_tcp_session_num);
printf("=> Session Manager: after add %lu new sessions\n", cfg.max_tcp_session_num);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess_used == opts.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess_opening == opts.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess_used == cfg.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess_opening == cfg.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0);
EXPECT_TRUE(stat->tcp_sess_closed == 0);
@@ -141,15 +145,15 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
// table full, evict new session
for (uint32_t i = 0; i < RX_BURST_MAX; i++)
{
packet_set_ip_src_addr(&pkt, opts.max_tcp_session_num + i);
packet_set_ip_src_addr(&pkt, cfg.max_tcp_session_num + i);
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL);
}
printf("=> Session Manager: after evicte new session\n");
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess_used == opts.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess_opening == opts.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess_used == cfg.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess_opening == cfg.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0);
EXPECT_TRUE(stat->tcp_sess_closed == 0);

62
infra/session_manager/test/gtest_overload_evict_udp_sess.cpp
View File

@@ -7,7 +7,7 @@
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = RX_BURST_MAX * 2,
.max_udp_session_num = RX_BURST_MAX * 2,
@@ -17,33 +17,37 @@ struct session_manager_options opts = {
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout = 1,
.tcp_handshake_timeout = 2,
.tcp_data_timeout = 3,
.tcp_half_closed_timeout = 4,
.tcp_time_wait_timeout = 5,
.tcp_discard_timeout = 6,
.tcp_unverified_rst_timeout = 7,
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout = 8,
.udp_discard_timeout = 0,
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
@@ -69,7 +73,7 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -80,15 +84,15 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
printf("<= Packet Parse: done\n\n");
// new session
for (uint32_t i = 0; i < opts.max_udp_session_num; i++)
for (uint32_t i = 0; i < cfg.max_udp_session_num; i++)
{
packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
}
printf("=> Session Manager: after add %lu new sessions\n", opts.max_udp_session_num);
printf("=> Session Manager: after add %lu new sessions\n", cfg.max_udp_session_num);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess_used == opts.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess_used == cfg.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_sess_active == 0);
EXPECT_TRUE(stat->udp_sess_closing == 0);
@@ -132,7 +136,7 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
// evicted session timeout
packet_set_ip_src_addr(&pkt, 0);
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1 + opts.evicted_session_filter_timeout));
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1 + cfg.evicted_session_filter_timeout_ms));
printf("=> Session Manager: after evicted session timeout\n");
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
@@ -155,11 +159,11 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
struct packet pkt;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
struct session_manager_options _opts;
memcpy(&_opts, &opts, sizeof(struct session_manager_options));
_opts.udp_overload_evict_old_sess = 0;
struct session_manager_config _cfg;
memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
_cfg.udp_overload_evict_old_sess = 0;
mgr = session_manager_new(&_opts, 1);
mgr = session_manager_new(&_cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -170,16 +174,16 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
printf("<= Packet Parse: done\n\n");
// new session
for (uint32_t i = 0; i < opts.max_udp_session_num; i++)
for (uint32_t i = 0; i < cfg.max_udp_session_num; i++)
{
packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
}
printf("=> Session Manager: after add %lu new sessions\n", opts.max_udp_session_num);
printf("=> Session Manager: after add %lu new sessions\n", cfg.max_udp_session_num);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess_used == opts.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess_opening == opts.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess_used == cfg.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess_opening == cfg.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess_active == 0);
EXPECT_TRUE(stat->udp_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess_closed == 0);
@@ -193,15 +197,15 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
// table full, evict new session
for (uint32_t i = 0; i < RX_BURST_MAX; i++)
{
packet_set_ip_src_addr(&pkt, opts.max_udp_session_num + i);
packet_set_ip_src_addr(&pkt, cfg.max_udp_session_num + i);
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL);
}
printf("=> Session Manager: after readd %d evicted session\n", RX_BURST_MAX);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess_used == opts.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess_opening == opts.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess_used == cfg.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess_opening == cfg.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess_active == 0);
EXPECT_TRUE(stat->udp_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess_closed == 0);

32
infra/session_manager/test/gtest_sess_mgr_scan.cpp
View File

@@ -6,7 +6,7 @@
#include "packet_parser.h"
#include "test_packets.h"
struct session_manager_options opts = {
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
@@ -16,33 +16,37 @@ struct session_manager_options opts = {
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout = 1,
.tcp_handshake_timeout = 2,
.tcp_data_timeout = 3,
.tcp_half_closed_timeout = 4,
.tcp_time_wait_timeout = 5,
.tcp_discard_timeout = 6,
.tcp_unverified_rst_timeout = 7,
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout = 8,
.udp_discard_timeout = 0,
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
@@ -131,7 +135,7 @@ TEST(SESS_MGR_SCAN, OPTS)
inet_pton(AF_INET6, "cafe::0000", &v6_dst_subnet_beg);
inet_pton(AF_INET6, "cafe::ffff", &v6_dst_subnet_end);
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);

42
infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp
View File

@@ -6,7 +6,7 @@
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
@@ -16,33 +16,37 @@ struct session_manager_options opts = {
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout = 1,
.tcp_handshake_timeout = 2,
.tcp_data_timeout = 3,
.tcp_half_closed_timeout = 4,
.tcp_time_wait_timeout = 5,
.tcp_discard_timeout = 6,
.tcp_unverified_rst_timeout = 7,
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout = 8,
.udp_discard_timeout = 0,
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
@@ -74,7 +78,7 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -245,8 +249,8 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
session_free_tcp_segment(sess, seg);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 7 + opts.tcp_data_timeout) == NULL); // active -> closing
sess = session_manager_get_expired_session(mgr, 7 + opts.tcp_data_timeout + opts.tcp_data_timeout); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 7 + cfg.tcp_data_timeout_ms) == NULL); // active -> closing
sess = session_manager_get_expired_session(mgr, 7 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -266,7 +270,7 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -339,8 +343,8 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
session_free_tcp_segment(sess, seg);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 4 + opts.tcp_data_timeout) == NULL); // active -> closing
sess = session_manager_get_expired_session(mgr, 4 + opts.tcp_data_timeout + opts.tcp_data_timeout); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 4 + cfg.tcp_data_timeout_ms) == NULL); // active -> closing
sess = session_manager_get_expired_session(mgr, 4 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);

56
infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp
View File

@@ -8,7 +8,7 @@
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
@@ -18,33 +18,37 @@ struct session_manager_options opts = {
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout = 1,
.tcp_handshake_timeout = 2,
.tcp_data_timeout = 3,
.tcp_half_closed_timeout = 4,
.tcp_time_wait_timeout = 5,
.tcp_discard_timeout = 6,
.tcp_unverified_rst_timeout = 7,
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout = 8,
.udp_discard_timeout = 0,
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
@@ -96,7 +100,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -155,7 +159,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_time_wait_timeout);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_time_wait_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
@@ -188,7 +192,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -241,7 +245,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_unverified_rst_timeout);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_unverified_rst_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
@@ -274,7 +278,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -327,7 +331,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_unverified_rst_timeout);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_unverified_rst_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
@@ -358,7 +362,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -374,8 +378,8 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout + opts.tcp_data_timeout);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -408,7 +412,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -455,7 +459,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_half_closed_timeout);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_half_closed_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
@@ -488,7 +492,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -535,7 +539,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_half_closed_timeout);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_half_closed_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);

78
infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp
View File

@@ -8,7 +8,7 @@
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
@@ -18,33 +18,37 @@ struct session_manager_options opts = {
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout = 1,
.tcp_handshake_timeout = 2,
.tcp_data_timeout = 3,
.tcp_half_closed_timeout = 4,
.tcp_time_wait_timeout = 5,
.tcp_discard_timeout = 6,
.tcp_unverified_rst_timeout = 7,
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout = 8,
.udp_discard_timeout = 0,
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
@@ -67,7 +71,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -111,8 +115,8 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_init_timeout) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + opts.tcp_init_timeout + opts.tcp_data_timeout); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms + cfg.tcp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -145,7 +149,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -189,8 +193,8 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_handshake_timeout) == NULL);
sess = session_manager_get_expired_session(mgr, 1 + opts.tcp_handshake_timeout + opts.tcp_data_timeout);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_handshake_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_handshake_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -223,7 +227,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -279,8 +283,8 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_handshake_timeout) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_handshake_timeout + opts.tcp_data_timeout);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_handshake_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_handshake_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -313,7 +317,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -381,8 +385,8 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + opts.tcp_data_timeout) == NULL);
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_data_timeout + opts.tcp_data_timeout);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + cfg.tcp_data_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -417,7 +421,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -478,8 +482,8 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_init_timeout) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_init_timeout + opts.tcp_data_timeout);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_init_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_init_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -514,7 +518,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -576,8 +580,8 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_handshake_timeout) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_handshake_timeout + opts.tcp_data_timeout);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_handshake_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_handshake_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -610,7 +614,7 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -666,8 +670,8 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout + opts.tcp_data_timeout);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -700,7 +704,7 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -756,8 +760,8 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout + opts.tcp_data_timeout);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);

34
infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
View File

@@ -8,7 +8,7 @@
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
@@ -18,33 +18,37 @@ struct session_manager_options opts = {
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout = 1,
.tcp_handshake_timeout = 2,
.tcp_data_timeout = 3,
.tcp_half_closed_timeout = 4,
.tcp_time_wait_timeout = 5,
.tcp_discard_timeout = 6,
.tcp_unverified_rst_timeout = 7,
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout = 8,
.udp_discard_timeout = 0,
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
@@ -63,7 +67,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -417,7 +421,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 11 + opts.tcp_time_wait_timeout);
sess = session_manager_get_expired_session(mgr, 11 + cfg.tcp_time_wait_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);

42
infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp
View File

@@ -8,7 +8,7 @@
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
@@ -18,33 +18,37 @@ struct session_manager_options opts = {
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout = 1,
.tcp_handshake_timeout = 2,
.tcp_data_timeout = 3,
.tcp_half_closed_timeout = 4,
.tcp_time_wait_timeout = 5,
.tcp_discard_timeout = 6,
.tcp_unverified_rst_timeout = 7,
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout = 8,
.udp_discard_timeout = 0,
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
@@ -67,7 +71,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -123,8 +127,8 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout + opts.tcp_data_timeout);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -157,7 +161,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -213,8 +217,8 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout + opts.tcp_data_timeout);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);

68
infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp
View File

@@ -8,7 +8,7 @@
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
@@ -18,33 +18,37 @@ struct session_manager_options opts = {
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout = 1,
.tcp_handshake_timeout = 2,
.tcp_data_timeout = 3,
.tcp_half_closed_timeout = 4,
.tcp_time_wait_timeout = 5,
.tcp_discard_timeout = 6,
.tcp_unverified_rst_timeout = 7,
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout = 8,
.udp_discard_timeout = 0,
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
@@ -67,7 +71,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -135,7 +139,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_time_wait_timeout);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_time_wait_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
@@ -168,7 +172,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -230,7 +234,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_unverified_rst_timeout);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_unverified_rst_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
@@ -263,7 +267,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -325,7 +329,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_unverified_rst_timeout);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_unverified_rst_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
@@ -357,7 +361,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -382,8 +386,8 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_init_timeout) == NULL);
sess = session_manager_get_expired_session(mgr, 1 + opts.tcp_init_timeout + opts.tcp_data_timeout);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -416,7 +420,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -472,8 +476,8 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_handshake_timeout) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_handshake_timeout + opts.tcp_data_timeout);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_handshake_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_handshake_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -506,7 +510,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -574,8 +578,8 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
EXPECT_TRUE(stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + opts.tcp_data_timeout) == NULL);
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_data_timeout + opts.tcp_data_timeout);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + cfg.tcp_data_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -608,7 +612,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -664,7 +668,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_half_closed_timeout);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_half_closed_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
@@ -697,7 +701,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -753,7 +757,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
EXPECT_TRUE(stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_half_closed_timeout);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_half_closed_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);

36
infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
View File

@@ -8,7 +8,7 @@
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
@@ -18,33 +18,37 @@ struct session_manager_options opts = {
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout = 1,
.tcp_handshake_timeout = 2,
.tcp_data_timeout = 3,
.tcp_half_closed_timeout = 4,
.tcp_time_wait_timeout = 5,
.tcp_discard_timeout = 6,
.tcp_unverified_rst_timeout = 7,
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout = 8,
.udp_discard_timeout = 0,
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
@@ -63,7 +67,7 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -137,8 +141,8 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
EXPECT_TRUE(stat->udp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.udp_data_timeout) == NULL); // active -> closing
sess = session_manager_get_expired_session(mgr, 2 + opts.udp_data_timeout + opts.udp_data_timeout); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.udp_data_timeout_ms) == NULL); // active -> closing
sess = session_manager_get_expired_session(mgr, 2 + cfg.udp_data_timeout_ms + cfg.udp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);

42
infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp
View File

@@ -8,7 +8,7 @@
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
@@ -18,33 +18,37 @@ struct session_manager_options opts = {
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout = 1,
.tcp_handshake_timeout = 2,
.tcp_data_timeout = 3,
.tcp_half_closed_timeout = 4,
.tcp_time_wait_timeout = 5,
.tcp_discard_timeout = 6,
.tcp_unverified_rst_timeout = 7,
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout = 8,
.udp_discard_timeout = 0,
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
@@ -68,7 +72,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -112,8 +116,8 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
EXPECT_TRUE(stat->udp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.udp_data_timeout) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + opts.udp_data_timeout + opts.udp_data_timeout); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_data_timeout_ms) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_data_timeout_ms + cfg.udp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -147,7 +151,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -191,8 +195,8 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
EXPECT_TRUE(stat->udp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.udp_data_timeout) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + opts.udp_data_timeout + opts.udp_data_timeout); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_data_timeout_ms) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_data_timeout_ms + cfg.udp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);

36
infra/session_manager/test/gtest_timeout_tcp_data.cpp
View File

@@ -7,7 +7,7 @@
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
@@ -17,33 +17,37 @@ struct session_manager_options opts = {
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout = 1,
.tcp_handshake_timeout = 2,
.tcp_data_timeout = 3,
.tcp_half_closed_timeout = 4,
.tcp_time_wait_timeout = 5,
.tcp_discard_timeout = 6,
.tcp_unverified_rst_timeout = 7,
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout = 8,
.udp_discard_timeout = 0,
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
@@ -60,7 +64,7 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -89,8 +93,8 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout + opts.tcp_data_timeout);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);

36
infra/session_manager/test/gtest_timeout_tcp_handshake.cpp
View File

@@ -7,7 +7,7 @@
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
@@ -17,33 +17,37 @@ struct session_manager_options opts = {
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout = 1,
.tcp_handshake_timeout = 2,
.tcp_data_timeout = 3,
.tcp_half_closed_timeout = 4,
.tcp_time_wait_timeout = 5,
.tcp_discard_timeout = 6,
.tcp_unverified_rst_timeout = 7,
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout = 8,
.udp_discard_timeout = 0,
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
@@ -60,7 +64,7 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -77,8 +81,8 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
EXPECT_TRUE(sess);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_handshake_timeout) == NULL);
sess = session_manager_get_expired_session(mgr, 1 + opts.tcp_handshake_timeout + opts.tcp_data_timeout);
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_handshake_timeout_ms) == NULL);
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_handshake_timeout_ms + cfg.tcp_data_timeout_ms);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);

36
infra/session_manager/test/gtest_timeout_tcp_init.cpp
View File

@@ -7,7 +7,7 @@
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
@@ -17,33 +17,37 @@ struct session_manager_options opts = {
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout = 1,
.tcp_handshake_timeout = 2,
.tcp_data_timeout = 3,
.tcp_half_closed_timeout = 4,
.tcp_time_wait_timeout = 5,
.tcp_discard_timeout = 6,
.tcp_unverified_rst_timeout = 7,
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout = 8,
.udp_discard_timeout = 0,
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
@@ -60,7 +64,7 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -77,8 +81,8 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT)
EXPECT_TRUE(sess);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_init_timeout) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + opts.tcp_init_timeout + opts.tcp_data_timeout); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms + cfg.tcp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);

42
infra/session_manager/test/gtest_timeout_udp_data.cpp
View File

@@ -7,7 +7,7 @@
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
struct session_manager_config cfg = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
@@ -17,33 +17,37 @@ struct session_manager_options opts = {
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_init_timeout = 1,
.tcp_handshake_timeout = 2,
.tcp_data_timeout = 3,
.tcp_half_closed_timeout = 4,
.tcp_time_wait_timeout = 5,
.tcp_discard_timeout = 6,
.tcp_unverified_rst_timeout = 7,
.tcp_init_timeout_ms = 1,
.tcp_handshake_timeout_ms = 2,
.tcp_data_timeout_ms = 3,
.tcp_half_closed_timeout_ms = 4,
.tcp_time_wait_timeout_ms = 5,
.tcp_discard_timeout_ms = 6,
.tcp_unverified_rst_timeout_ms = 7,
// udp timeout
.udp_data_timeout = 8,
.udp_discard_timeout = 0,
.udp_data_timeout_ms = 8,
.udp_discard_timeout_ms = 0,
// limit
.session_expire_polling_interval_ms = 0,
.session_expire_polling_limit = 1024,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_timeout_ms = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_timeout_ms = 10,
.evicted_session_filter_error_rate = 0.0001,
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_timeout_ms = 60000,
.tcp_reassembly_max_segments = 16,
};
@@ -60,7 +64,7 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -77,8 +81,8 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
EXPECT_TRUE(sess);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.udp_data_timeout) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + opts.udp_data_timeout + opts.udp_data_timeout); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_data_timeout_ms) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_data_timeout_ms + cfg.udp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
@@ -97,7 +101,7 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
mgr = session_manager_new(&opts, 1);
mgr = session_manager_new(&cfg, 1);
EXPECT_TRUE(mgr != NULL);
session_manager_set_session_id_generator(mgr, session_id_generator);
@@ -126,8 +130,8 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.udp_data_timeout) == NULL); // active -> closing
sess = session_manager_get_expired_session(mgr, 2 + opts.udp_data_timeout + opts.udp_data_timeout); // closing -> closed
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.udp_data_timeout_ms) == NULL); // active -> closing
sess = session_manager_get_expired_session(mgr, 2 + cfg.udp_data_timeout_ms + cfg.udp_data_timeout_ms); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);

37
test/decoders/http/test_based_on_stellar/env/stellar.toml vendored
View File

@@ -10,7 +10,7 @@ dev_symbol = "nf_0_fw"
dumpfile_path = "./pcap/test.pcap"
#dumpfile_path = "/tmp/dumpfile/dumpfilelist"
nr_threads = 1 # [1, 256]
nr_worker_thread = 1 # [1, 256]
cpu_mask = [5, 6, 7, 8, 9, 10, 11, 12]
[ip_reassembly]
@@ -29,40 +29,39 @@ tcp_overload_evict_old_sess = 1 # 1: evict old session, 0: bypass new session
udp_overload_evict_old_sess = 1 # 1: evict old session, 0: bypass new session
# TCP timeout
tcp_init_timeout = 50 # range: [1, 60000] (ms)
tcp_handshake_timeout = 50 # range: [1, 60000] (ms)
tcp_data_timeout = 50 # range: [1, 15999999000] (ms)
tcp_half_closed_timeout = 50 # range: [1, 604800000] (ms)
tcp_time_wait_timeout = 50 # range: [1, 600000] (ms)
tcp_discard_timeout = 10 # range: [1, 15999999000] (ms)
tcp_unverified_rst_timeout = 50 # range: [1, 600000] (ms)
tcp_init_timeout_ms = 50 # range: [1, 60000] (ms)
tcp_handshake_timeout_ms = 50 # range: [1, 60000] (ms)
tcp_data_timeout_ms = 50 # range: [1, 15999999000] (ms)
tcp_half_closed_timeout_ms = 50 # range: [1, 604800000] (ms)
tcp_time_wait_timeout_ms = 50 # range: [1, 600000] (ms)
tcp_discard_timeout_ms = 10 # range: [1, 15999999000] (ms)
tcp_unverified_rst_timeout_ms = 50 # range: [1, 600000] (ms)
# UDP timeout
udp_data_timeout = 50 # range: [1, 15999999000] (ms)
udp_discard_timeout = 50 # range: [1, 15999999000] (ms)
udp_data_timeout_ms = 50 # range: [1, 15999999000] (ms)
udp_discard_timeout_ms = 50 # range: [1, 15999999000] (ms)
# limit
session_expire_polling_interval_ms = 0 # range: [0, 60000] (ms)
session_expire_polling_limit = 1024 # range: [1, 1024]
# duplicate packet filter
duplicated_packet_filter_enable = 1
duplicated_packet_filter_capacity = 1000000 # range: [1, 4294967295]
duplicated_packet_filter_timeout = 10000 # range: [1, 60000] (ms)
duplicated_packet_filter_timeout_ms = 10000 # range: [1, 60000] (ms)
duplicated_packet_filter_error_rate = 0.00001 # range: [0.0, 1.0]
# evicted session filter
evicted_session_filter_enable = 1
evicted_session_filter_capacity = 1000000 # range: [1, 4294967295]
evicted_session_filter_timeout = 10000 # range: [1, 60000] (ms)
evicted_session_filter_timeout_ms = 10000 # range: [1, 60000] (ms)
evicted_session_filter_error_rate = 0.00001 # range: [0.0, 1.0]
# TCP reassembly (Per direction)
tcp_reassembly_enable = 1
tcp_reassembly_max_timeout = 10000 # range: [1, 60000] (ms)
tcp_reassembly_max_segments = 256 # range: [2, 4096]
tcp_reassembly_max_timeout_ms = 10000 # range: [1, 60000] (ms)
tcp_reassembly_max_segments = 256 # range: [2, 4096]
[schedule]
# Note: free_expired_session_interval determines the precision of session_manager timeout
free_expired_session_interval = 50 # range: [1, 60000] (ms)
free_expired_session_batch = 100 # range: [1, 60000]
force_session_expire_before_exit = 0 # 1: force session to expire before exit, 0: wait for session to naturally expire before exit.
# Note: free_expired_ip_frag_interval determines the precision of ip_reassembly timeout
free_expired_ip_frag_interval = 50 # range: [1, 60000] (ms)
free_expired_ip_frag_batch = 100 # range: [1, 60000]

37
test/packet_inject/conf/stellar.toml
View File

@@ -10,7 +10,7 @@ dev_symbol = "nf_0_fw"
dumpfile_path = "/tmp/dumpfile/dumpfile.pcap"
#dumpfile_path = "/tmp/dumpfile/dumpfilelist"
nr_threads = 1 # [1, 256]
nr_worker_thread = 1 # [1, 256]
cpu_mask = [5]
[ip_reassembly]
@@ -29,40 +29,39 @@ tcp_overload_evict_old_sess = 1 # 1: evict old session, 0: bypass new session
udp_overload_evict_old_sess = 1 # 1: evict old session, 0: bypass new session
# TCP timeout
tcp_init_timeout = 50 # range: [1, 60000] (ms)
tcp_handshake_timeout = 50 # range: [1, 60000] (ms)
tcp_data_timeout = 50 # range: [1, 15999999000] (ms)
tcp_half_closed_timeout = 50 # range: [1, 604800000] (ms)
tcp_time_wait_timeout = 50 # range: [1, 600000] (ms)
tcp_discard_timeout = 50 # range: [1, 15999999000] (ms)
tcp_unverified_rst_timeout = 50 # range: [1, 600000] (ms)
tcp_init_timeout_ms = 50 # range: [1, 60000] (ms)
tcp_handshake_timeout_ms = 50 # range: [1, 60000] (ms)
tcp_data_timeout_ms = 50 # range: [1, 15999999000] (ms)
tcp_half_closed_timeout_ms = 50 # range: [1, 604800000] (ms)
tcp_time_wait_timeout_ms = 50 # range: [1, 600000] (ms)
tcp_discard_timeout_ms = 50 # range: [1, 15999999000] (ms)
tcp_unverified_rst_timeout_ms = 50 # range: [1, 600000] (ms)
# UDP timeout
udp_data_timeout = 50 # range: [1, 15999999000] (ms)
udp_discard_timeout = 50 # range: [1, 15999999000] (ms)
udp_data_timeout_ms = 50 # range: [1, 15999999000] (ms)
udp_discard_timeout_ms = 50 # range: [1, 15999999000] (ms)
# limit
session_expire_polling_interval_ms = 0 # range: [0, 60000] (ms)
session_expire_polling_limit = 1024 # range: [1, 1024]
# duplicate packet filter
duplicated_packet_filter_enable = 1
duplicated_packet_filter_capacity = 1000000 # range: [1, 4294967295]
duplicated_packet_filter_timeout = 100 # range: [1, 60000] (ms)
duplicated_packet_filter_timeout_ms = 100 # range: [1, 60000] (ms)
duplicated_packet_filter_error_rate = 0.00001 # range: [0.0, 1.0]
# evicted session filter
evicted_session_filter_enable = 1
evicted_session_filter_capacity = 1000000 # range: [1, 4294967295]
evicted_session_filter_timeout = 100 # range: [1, 60000] (ms)
evicted_session_filter_timeout_ms = 100 # range: [1, 60000] (ms)
evicted_session_filter_error_rate = 0.00001 # range: [0.0, 1.0]
# TCP reassembly (Per direction)
tcp_reassembly_enable = 1
tcp_reassembly_max_timeout = 10000 # range: [1, 60000] (ms)
tcp_reassembly_max_segments = 128 # range: [2, 4096]
tcp_reassembly_max_timeout_ms = 10000 # range: [1, 60000] (ms)
tcp_reassembly_max_segments = 128 # range: [2, 4096]
[schedule]
# Note: free_expired_session_interval determines the precision of session_manager timeout
free_expired_session_interval = 50 # range: [1, 60000] (ms)
free_expired_session_batch = 1000 # range: [1, 60000]
force_session_expire_before_exit = 0 # 1: force session to expire before exit, 0: wait for session to naturally expire before exit.
# Note: free_expired_ip_frag_interval determines the precision of ip_reassembly timeout
free_expired_ip_frag_interval = 50 # range: [1, 60000] (ms)
free_expired_ip_frag_batch = 1000 # range: [1, 60000]