diff --git a/conf/stellar.toml b/conf/stellar.toml index 880fad6..ee4c8cb 100644 --- a/conf/stellar.toml +++ b/conf/stellar.toml @@ -1,67 +1,65 @@ [snowflake] -snowflake_base = 1 # [0, 31] -snowflake_offset = 2 # [0, 127] + snowflake_base = 1 # [0, 31] + snowflake_offset = 2 # [0, 127] [packet_io] -mode = "pcapfile" # pcapfile, pcaplist, marsio -app_symbol = "stellar" -dev_symbol = "nf_0_fw" -pcap_path = "/tmp/test.pcap" -nr_worker_thread = 1 # range: [1, 256] -cpu_mask = [5, 6, 7, 8, 9, 10, 11, 12] -idle_yield_interval_ms = 900 # range: [0, 60000] (ms) + mode = "pcapfile" # pcapfile, pcaplist, marsio + app_symbol = "stellar" + dev_symbol = "nf_0_fw" + pcap_path = "/tmp/test.pcap" + nr_worker_thread = 1 # range: [1, 256] + cpu_mask = [5, 6, 7, 8, 9, 10, 11, 12] + idle_yield_interval_ms = 900 # range: [0, 60000] (ms) [ip_reassembly] -enable = 1 -bucket_entries = 32 # range: [1, 4294967295] (must be power of 2) -bucket_num = 1024 # range: [1, 4294967295] + enable = 1 + bucket_entries = 32 # range: [1, 4294967295] (must be power of 2) + bucket_num = 1024 # range: [1, 4294967295] -ip_frag_timeout_ms = 10000 # range: [1, 60000] (ms) -ip_frag_expire_polling_interval_ms = 0 # range: [0, 60000] (ms) -ip_frag_expire_polling_limit = 1024 # range: [1, 1024] + ip_frag_timeout_ms = 10000 # range: [1, 60000] (ms) + ip_frag_expire_polling_interval_ms = 0 # range: [0, 60000] (ms) + ip_frag_expire_polling_limit = 1024 # range: [1, 1024] [session_manager] -# max session number -max_tcp_session_num = 50000 -max_udp_session_num = 50000 + tcp_session_max = 50000 + udp_session_max = 50000 -# session overload evict -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 + evict_old_on_tcp_table_limit = 1 # range: [0, 1] + evict_old_on_udp_table_limit = 1 # range: [0, 1] -# TCP timeout -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_ms = 5000 # range: [1, 15999999000] (ms) -udp_discard_timeout_ms = 5000 # range: [1, 15999999000] (ms) + expire_period_ms = 0 # range: [0, 60000] (ms) + expire_batch_max = 1024 # range: [1, 1024] -# limit -session_expire_polling_interval_ms = 0 # range: [0, 60000] (ms) -session_expire_polling_limit = 1024 # range: [1, 1024] + [session_manager.tcp_timeout_ms] + init = 5000 # range: [1, 60000] (ms) + handshake = 5000 # range: [1, 60000] (ms) + data = 5000 # range: [1, 15999999000] (ms) + half_closed = 5000 # range: [1, 604800000] (ms) + time_wait = 5000 # range: [1, 600000] (ms) + discard_default = 10000 # range: [1, 15999999000] (ms) + unverified_rst = 5000 # range: [1, 600000] (ms) -# duplicate packet filter -duplicated_packet_filter_enable = 1 -duplicated_packet_filter_capacity = 1000000 # range: [1, 4294967295] -duplicated_packet_filter_timeout_ms = 10000 # range: [1, 60000] (ms) -duplicated_packet_filter_error_rate = 0.00001 # range: [0.0, 1.0] + [session_manager.udp_timeout_ms] + data = 5000 # range: [1, 15999999000] (ms) + discard_default = 5000 # range: [1, 15999999000] (ms) -# evicted session filter -evicted_session_filter_enable = 1 -evicted_session_filter_capacity = 1000000 # range: [1, 4294967295] -evicted_session_filter_timeout_ms = 10000 # range: [1, 60000] (ms) -evicted_session_filter_error_rate = 0.00001 # range: [0.0, 1.0] + [session_manager.duplicated_packet_bloom_filter] + enable = 1 + capacity = 1000000 # range: [1, 4294967295] + time_window_ms = 10000 # range: [1, 60000] (ms) + error_rate = 0.00001 # range: [0.0, 1.0] -# TCP reassembly (Per direction) -tcp_reassembly_enable = 1 -tcp_reassembly_max_timeout_ms = 10000 # range: [1, 60000] (ms) -tcp_reassembly_max_segments = 256 # range: [2, 4096] + [session_manager.evicted_session_bloom_filter] + enable = 1 # range: [0, 1] + capacity = 1000000 # range: [1, 4294967295] + time_window_ms = 10000 # range: [1, 60000] (ms) + error_rate = 0.00001 # range: [0.0, 1.0] + + [session_manager.tcp_reassembly] + enable = 1 # range: [0, 1] + timeout_ms = 10000 # range: [1, 60000] (ms) + buffered_segments_max = 256 # range: [2, 4096] per flow [schedule] -merge_stat_interval = 500 # range: [1, 60000] (ms) -output_stat_interval = 2000 # range: [1, 60000] (ms) + merge_stat_interval = 500 # range: [1, 60000] (ms) + output_stat_interval = 2000 # range: [1, 60000] (ms) diff --git a/infra/core/utils.h b/infra/core/utils.h index 38514ca..78f5fe8 100644 --- a/infra/core/utils.h +++ b/infra/core/utils.h @@ -5,9 +5,15 @@ extern "C" { #endif -#include -#include #include +#include +#include +#include +#include +#include + +#include "toml.h" +#include "log_private.h" #define RX_BURST_MAX 32 #define MAX_THREAD_NUM 256 // limit by snowflake @@ -97,6 +103,136 @@ static inline void hexdump_to_fd(int fd, uint32_t idx, const char *data, uint16_ } } +// key: "a.b.c" +static inline const char *get_toml_value_from_hierarchical_key(toml_table_t *root, const char *key) +{ + toml_table_t *table = root; + + char *saveptr; + char *dup_key = strdup(key); + char *token = strtok_r(dup_key, ".", &saveptr); + + while (token != NULL) + { + table = toml_table_in(table, token); + if (table == NULL) + { + free(dup_key); + return NULL; + } + + if (strchr(saveptr, '.') == NULL) + { + const char *val = toml_raw_in(table, saveptr); + free(dup_key); + return val; + } + + token = strtok_r(NULL, ".", &saveptr); + } + + free(dup_key); + return toml_raw_in(root, key); +} + +static inline int load_and_validate_toml_integer_config(const char *toml_file, const char *key, uint64_t *val, uint64_t min, uint64_t max) +{ + int ret = -1; + char errbuf[200]; + const char *ptr = NULL; + FILE *fp = NULL; + toml_table_t *root = NULL; + + fp = fopen(toml_file, "r"); + if (fp == NULL) + { + STELLAR_LOG_ERROR(__thread_local_logger, "config", "config file %s open failed, %s", toml_file, strerror(errno)); + return -1; + } + + root = toml_parse_file(fp, errbuf, sizeof(errbuf)); + if (root == NULL) + { + STELLAR_LOG_ERROR(__thread_local_logger, "config", "config file %s parse failed, %s", toml_file, errbuf); + goto error_out; + } + + ptr = get_toml_value_from_hierarchical_key(root, key); + if (ptr == NULL) + { + STELLAR_LOG_ERROR(__thread_local_logger, "config", "config file missing %s", key); + goto error_out; + } + + *val = atoll(ptr); + if ((*val) < min || (*val) > max) + { + STELLAR_LOG_ERROR(__thread_local_logger, "config", "invalid %s: %lu, supported range: [%lu, %lu]", key, *val, min, max); + goto error_out; + } + + ret = 0; +error_out: + if (root != NULL) + { + toml_free(root); + } + if (fp) + { + fclose(fp); + } + return ret; +} + +static inline int load_and_validate_toml_double_config(const char *toml_file, const char *key, double *val, double min, double max) +{ + int ret = -1; + char errbuf[200]; + const char *ptr = NULL; + FILE *fp = NULL; + toml_table_t *root = NULL; + + fp = fopen(toml_file, "r"); + if (fp == NULL) + { + STELLAR_LOG_ERROR(__thread_local_logger, "config", "config file %s open failed, %s", toml_file, strerror(errno)); + return -1; + } + + root = toml_parse_file(fp, errbuf, sizeof(errbuf)); + if (root == NULL) + { + STELLAR_LOG_ERROR(__thread_local_logger, "config", "config file %s parse failed, %s", toml_file, errbuf); + goto error_out; + } + + ptr = get_toml_value_from_hierarchical_key(root, key); + if (ptr == NULL) + { + STELLAR_LOG_ERROR(__thread_local_logger, "config", "config file missing %s", key); + goto error_out; + } + + *val = atof(ptr); + if ((*val) < min || (*val) > max) + { + STELLAR_LOG_ERROR(__thread_local_logger, "config", "invalid %s: %f, supported range: [%f, %f]", key, *val, min, max); + goto error_out; + } + + ret = 0; +error_out: + if (root != NULL) + { + toml_free(root); + } + if (fp) + { + fclose(fp); + } + return ret; +} + #ifdef __cplusplus } #endif diff --git a/infra/ip_reassembly/ip_reassembly.c b/infra/ip_reassembly/ip_reassembly.c index bfa228b..fa4f314 100644 --- a/infra/ip_reassembly/ip_reassembly.c +++ b/infra/ip_reassembly/ip_reassembly.c @@ -4,10 +4,9 @@ #include #include -#include "toml.h" +#include "utils.h" #include "checksum.h" #include "crc32_hash.h" -#include "log_private.h" #include "ip_reassembly.h" #include "packet_parser.h" #include "packet_helper.h" @@ -726,84 +725,6 @@ error_out_overlap: * Public API ******************************************************************************/ -#define PARSE_AND_CHECK_NUM(table, key, val, min, max) \ - do \ - { \ - const char *ptr = toml_raw_in(table, (key)); \ - if (ptr == NULL) \ - { \ - IP_REASSEMBLE_ERROR("config file missing ip_reassembly.%s", (key)); \ - goto error_out; \ - } \ - (val) = atoll(ptr); \ - if ((val) < (min) || (val) > (max)) \ - { \ - IP_REASSEMBLE_ERROR("invalid ip_reassembly.%s: %lu, supported range: [%lu, %lu]", (key), (val), (min), (max)); \ - goto error_out; \ - } \ - } while (0) - -int ip_reassembly_config_load(struct ip_reassembly_config *cfg, const char *toml_file) -{ - 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) - { - IP_REASSEMBLE_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) - { - IP_REASSEMBLE_ERROR("config file %s parse failed, %s", toml_file, errbuf); - goto error_out; - } - - table = toml_table_in(root, "ip_reassembly"); - if (table == NULL) - { - IP_REASSEMBLE_ERROR("config file %s missing ip_reassembly", toml_file); - goto error_out; - } - - PARSE_AND_CHECK_NUM(table, "enable", cfg->enable, zero, 1); - - if (cfg->enable) - { - PARSE_AND_CHECK_NUM(table, "bucket_entries", cfg->bucket_entries, 1, 4294967295); - PARSE_AND_CHECK_NUM(table, "bucket_num", cfg->bucket_num, 1, 4294967295); - PARSE_AND_CHECK_NUM(table, "ip_frag_timeout_ms", cfg->ip_frag_timeout_ms, 1, 60000); - PARSE_AND_CHECK_NUM(table, "ip_frag_expire_polling_interval_ms", cfg->ip_frag_expire_polling_interval_ms, zero, 60000); - PARSE_AND_CHECK_NUM(table, "ip_frag_expire_polling_limit", cfg->ip_frag_expire_polling_limit, 1, 1024); - - if (is_power_of_2(cfg->bucket_entries) == 0) - { - IP_REASSEMBLE_ERROR("invalid ip_reassembly.bucket_entries: %lu, must be power of 2", cfg->bucket_entries); - goto error_out; - } - } - - ret = 0; -error_out: - if (root) - { - toml_free(root); - } - if (fp) - { - fclose(fp); - } - - return ret; -} - struct ip_reassembly_config *ip_reassembly_config_new(const char *toml_file) { if (toml_file == NULL) @@ -817,7 +738,20 @@ struct ip_reassembly_config *ip_reassembly_config_new(const char *toml_file) return NULL; } - if (ip_reassembly_config_load(cfg, toml_file) == -1) + int ret = 0; + ret += load_and_validate_toml_integer_config(toml_file, "ip_reassembly.enable", (uint64_t *)&cfg->enable, 0, 1); + ret += load_and_validate_toml_integer_config(toml_file, "ip_reassembly.bucket_entries", (uint64_t *)&cfg->bucket_entries, 1, 4294967295); + ret += load_and_validate_toml_integer_config(toml_file, "ip_reassembly.bucket_num", (uint64_t *)&cfg->bucket_num, 1, 4294967295); + ret += load_and_validate_toml_integer_config(toml_file, "ip_reassembly.ip_frag_timeout_ms", (uint64_t *)&cfg->ip_frag_timeout_ms, 1, 60000); + ret += load_and_validate_toml_integer_config(toml_file, "ip_reassembly.ip_frag_expire_polling_interval_ms", (uint64_t *)&cfg->ip_frag_expire_polling_interval_ms, 0, 60000); + ret += load_and_validate_toml_integer_config(toml_file, "ip_reassembly.ip_frag_expire_polling_limit", (uint64_t *)&cfg->ip_frag_expire_polling_limit, 1, 1024); + + if (is_power_of_2(cfg->bucket_entries) == 0) + { + IP_REASSEMBLE_ERROR("invalid ip_reassembly.bucket_entries: %lu, must be power of 2", cfg->bucket_entries); + ret += -1; + } + if (ret != 0) { ip_reassembly_config_free(cfg); return NULL; diff --git a/infra/packet_io/packet_io.c b/infra/packet_io/packet_io.c index 42a9743..76d5981 100644 --- a/infra/packet_io/packet_io.c +++ b/infra/packet_io/packet_io.c @@ -32,7 +32,7 @@ int packet_io_config_load(struct packet_io_config *cfg, const char *toml_file) int ret = -1; const char *ptr; char *ptr_mode = NULL; - char *ptr_dumpfile_path = NULL; + char *ptr_pcap_path = NULL; char *ptr_app_symbol = NULL; char *ptr_dev_symbol = NULL; char errbuf[200]; @@ -89,12 +89,12 @@ int packet_io_config_load(struct packet_io_config *cfg, const char *toml_file) if (cfg->mode == PACKET_IO_PCAPFILE || cfg->mode == PACKET_IO_PCAPLIST) { ptr = toml_raw_in(table, "pcap_path"); - if (ptr == NULL || toml_rtos(ptr, &ptr_dumpfile_path) != 0) + if (ptr == NULL || toml_rtos(ptr, &ptr_pcap_path) != 0) { PACKET_IO_LOG_ERROR("config file missing packet_io.pcap_path"); goto error_out; } - strcpy(cfg->pcap_path, ptr_dumpfile_path); + strcpy(cfg->pcap_path, ptr_pcap_path); } else { @@ -164,9 +164,9 @@ error_out: { free(ptr_mode); } - if (ptr_dumpfile_path) + if (ptr_pcap_path) { - free(ptr_dumpfile_path); + free(ptr_pcap_path); } if (ptr_app_symbol) { diff --git a/infra/session_manager/session_manager.c b/infra/session_manager/session_manager.c index 2df188a..956888e 100644 --- a/infra/session_manager/session_manager.c +++ b/infra/session_manager/session_manager.c @@ -4,8 +4,6 @@ #include #include "utils.h" -#include "toml.h" -#include "log_private.h" #include "packet_helper.h" #include "packet_filter.h" #include "session_private.h" @@ -141,13 +139,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->cfg.tcp_reassembly_enable) + if (!mgr->cfg.tcp_reassembly.enable) { return 0; } - 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); + sess->tcp_halfs[FLOW_DIRECTION_C2S].assembler = tcp_reassembly_new(mgr->cfg.tcp_reassembly.timeout_ms, mgr->cfg.tcp_reassembly.buffered_segments_max); + sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler = tcp_reassembly_new(mgr->cfg.tcp_reassembly.timeout_ms, mgr->cfg.tcp_reassembly.buffered_segments_max); if (sess->tcp_halfs[FLOW_DIRECTION_C2S].assembler == NULL || sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler == NULL) { tcp_clean(mgr, sess); @@ -180,7 +178,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->cfg.tcp_reassembly_enable) + if (!mgr->cfg.tcp_reassembly.enable) { if (len) { @@ -330,7 +328,7 @@ static enum flow_direction identify_direction_by_history(const struct session *s // 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->cfg.max_tcp_session_num) + if (key->ip_proto == IPPROTO_TCP && mgr->stat.tcp_sess_used >= mgr->cfg.tcp_session_max) { mgr->stat.tcp_pkts_bypass_table_full++; return 1; @@ -340,7 +338,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->cfg.max_udp_session_num) + if (key->ip_proto == IPPROTO_UDP && mgr->stat.udp_sess_used >= mgr->cfg.udp_session_max) { mgr->stat.udp_pkts_bypass_table_full++; return 1; @@ -350,7 +348,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->cfg.evicted_session_filter_enable && session_filter_lookup(mgr->evicte_sess_filter, key, mgr->now_ms)) + if (mgr->cfg.evicted_session_bloom_filter.enable && session_filter_lookup(mgr->evicte_sess_filter, key, mgr->now_ms)) { mgr->stat.udp_pkts_bypass_session_evicted++; return 1; @@ -362,7 +360,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->cfg.duplicated_packet_filter_enable == 0) + if (mgr->cfg.duplicated_packet_bloom_filter.enable == 0) { return 0; } @@ -517,7 +515,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->cfg.evicted_session_filter_enable) + if (mgr->cfg.evicted_session_bloom_filter.enable) { session_filter_add(mgr->evicte_sess_filter, session_get_tuple6(sess), mgr->now_ms); } @@ -574,7 +572,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m } // tcp table full evict old session - if (mgr->cfg.tcp_overload_evict_old_sess && mgr->stat.tcp_sess_used >= mgr->cfg.max_tcp_session_num - EVICTE_SESSION_BURST) + if (mgr->cfg.evict_old_on_tcp_table_limit && mgr->stat.tcp_sess_used >= mgr->cfg.tcp_session_max - EVICTE_SESSION_BURST) { struct session *evic_sess = session_table_find_lru(mgr->tcp_sess_table); session_manager_evicte_session(mgr, evic_sess, LRU_EVICT); @@ -603,11 +601,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->cfg.tcp_handshake_timeout_ms : mgr->cfg.tcp_init_timeout_ms; + uint64_t timeout = (flags & TH_ACK) ? mgr->cfg.tcp_timeout_ms.handshake : mgr->cfg.tcp_timeout_ms.init; session_timer_update(mgr->sess_timer, sess, mgr->now_ms + timeout); session_table_add(mgr->tcp_sess_table, sess); - if (mgr->cfg.duplicated_packet_filter_enable) + if (mgr->cfg.duplicated_packet_bloom_filter.enable) { packet_filter_add(mgr->dup_pkt_filter, pkt, mgr->now_ms); } @@ -622,7 +620,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->cfg.udp_overload_evict_old_sess && mgr->stat.udp_sess_used >= mgr->cfg.max_udp_session_num - EVICTE_SESSION_BURST) + if (mgr->cfg.evict_old_on_udp_table_limit && mgr->stat.udp_sess_used >= mgr->cfg.udp_session_max - EVICTE_SESSION_BURST) { struct session *evic_sess = session_table_find_lru(mgr->udp_sess_table); session_manager_evicte_session(mgr, evic_sess, LRU_EVICT); @@ -643,7 +641,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->cfg.udp_data_timeout_ms); + session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->cfg.udp_timeout_ms.data); session_table_add(mgr->udp_sess_table, sess); SESS_MGR_STAT_INC(&mgr->stat, next_state, udp); @@ -698,34 +696,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->cfg.tcp_handshake_timeout_ms : mgr->cfg.tcp_init_timeout_ms; + timeout = (flags & TH_ACK) ? mgr->cfg.tcp_timeout_ms.handshake : mgr->cfg.tcp_timeout_ms.init; } else { - timeout = mgr->cfg.tcp_data_timeout_ms; + timeout = mgr->cfg.tcp_timeout_ms.data; } break; case SESSION_STATE_ACTIVE: - timeout = mgr->cfg.tcp_data_timeout_ms; + timeout = mgr->cfg.tcp_timeout_ms.data; break; case SESSION_STATE_CLOSING: if (flags & TH_FIN) { - timeout = (peer->history & TH_FIN) ? mgr->cfg.tcp_time_wait_timeout_ms : mgr->cfg.tcp_half_closed_timeout_ms; + timeout = (peer->history & TH_FIN) ? mgr->cfg.tcp_timeout_ms.time_wait : mgr->cfg.tcp_timeout_ms.half_closed; } 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->cfg.tcp_time_wait_timeout_ms : mgr->cfg.tcp_unverified_rst_timeout_ms; + timeout = (expected == curr->seq) ? mgr->cfg.tcp_timeout_ms.time_wait : mgr->cfg.tcp_timeout_ms.unverified_rst; } else { - timeout = mgr->cfg.tcp_data_timeout_ms; + timeout = mgr->cfg.tcp_timeout_ms.data; } break; case SESSION_STATE_DISCARD: - timeout = mgr->cfg.tcp_discard_timeout_ms; + timeout = mgr->cfg.tcp_timeout_ms.discard_default; break; default: assert(0); @@ -748,11 +746,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->cfg.udp_discard_timeout_ms); + session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->cfg.udp_timeout_ms.discard_default); } else { - session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->cfg.udp_data_timeout_ms); + session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->cfg.udp_timeout_ms.data); } SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, udp); @@ -774,127 +772,6 @@ static inline uint8_t ipv6_in_range(const struct in6_addr *addr, const struct in * session manager public API ******************************************************************************/ -#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) -{ - 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) @@ -908,7 +785,42 @@ struct session_manager_config *session_manager_config_new(const char *toml_file) return NULL; } - if (session_manager_config_load(cfg, toml_file) == -1) + int ret = 0; + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.tcp_session_max", (uint64_t *)&cfg->tcp_session_max, EVICTE_SESSION_BURST * 2, UINT64_MAX); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.udp_session_max", (uint64_t *)&cfg->udp_session_max, EVICTE_SESSION_BURST * 2, UINT64_MAX); + + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.evict_old_on_tcp_table_limit", (uint64_t *)&cfg->evict_old_on_tcp_table_limit, 0, 1); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.evict_old_on_udp_table_limit", (uint64_t *)&cfg->evict_old_on_udp_table_limit, 0, 1); + + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.expire_period_ms", (uint64_t *)&cfg->expire_period_ms, 0, 60000); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.expire_batch_max", (uint64_t *)&cfg->expire_batch_max, 1, 1024); + + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.init", (uint64_t *)&cfg->tcp_timeout_ms.init, 1, 60000); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.handshake", (uint64_t *)&cfg->tcp_timeout_ms.handshake, 1, 60000); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.data", (uint64_t *)&cfg->tcp_timeout_ms.data, 1, 15999999000); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.half_closed", (uint64_t *)&cfg->tcp_timeout_ms.half_closed, 1, 604800000); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.time_wait", (uint64_t *)&cfg->tcp_timeout_ms.time_wait, 1, 60000); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.discard_default", (uint64_t *)&cfg->tcp_timeout_ms.discard_default, 1, 15999999000); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.unverified_rst", (uint64_t *)&cfg->tcp_timeout_ms.unverified_rst, 1, 60000); + + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.udp_timeout_ms.data", (uint64_t *)&cfg->udp_timeout_ms.data, 1, 15999999000); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.udp_timeout_ms.discard_default", (uint64_t *)&cfg->udp_timeout_ms.discard_default, 1, 15999999000); + + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.duplicated_packet_bloom_filter.enable", (uint64_t *)&cfg->duplicated_packet_bloom_filter.enable, 0, 1); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.duplicated_packet_bloom_filter.capacity", (uint64_t *)&cfg->duplicated_packet_bloom_filter.capacity, 1, 4294967295); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.duplicated_packet_bloom_filter.time_window_ms", (uint64_t *)&cfg->duplicated_packet_bloom_filter.time_window_ms, 1, 60000); + ret += load_and_validate_toml_double_config(toml_file, "session_manager.duplicated_packet_bloom_filter.error_rate", (double *)&cfg->duplicated_packet_bloom_filter.error_rate, 0.0, 1.0); + + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.evicted_session_bloom_filter.enable", (uint64_t *)&cfg->evicted_session_bloom_filter.enable, 0, 1); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.evicted_session_bloom_filter.capacity", (uint64_t *)&cfg->evicted_session_bloom_filter.capacity, 1, 4294967295); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.evicted_session_bloom_filter.time_window_ms", (uint64_t *)&cfg->evicted_session_bloom_filter.time_window_ms, 1, 60000); + ret += load_and_validate_toml_double_config(toml_file, "session_manager.evicted_session_bloom_filter.error_rate", (double *)&cfg->evicted_session_bloom_filter.error_rate, 0.0, 1.0); + + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.tcp_reassembly.enable", (uint64_t *)&cfg->tcp_reassembly.enable, 0, 1); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.tcp_reassembly.timeout_ms", (uint64_t *)&cfg->tcp_reassembly.timeout_ms, 1, 60000); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.tcp_reassembly.buffered_segments_max", (uint64_t *)&cfg->tcp_reassembly.buffered_segments_max, 1, 512); + + if (ret != 0) { session_manager_config_free(cfg); return NULL; @@ -931,46 +843,46 @@ 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_LOG_INFO("session_manager.tcp_session_max : %lu", cfg->tcp_session_max); + SESSION_LOG_INFO("session_manager.udp_session_max : %lu", cfg->udp_session_max); // 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); + SESSION_LOG_INFO("session_manager.evict_old_on_tcp_table_limit : %d", cfg->evict_old_on_tcp_table_limit); + SESSION_LOG_INFO("session_manager.evict_old_on_udp_table_limit : %d", cfg->evict_old_on_udp_table_limit); // 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); + SESSION_LOG_INFO("session_manager.tcp_timeout_ms.init : %lu", cfg->tcp_timeout_ms.init); + SESSION_LOG_INFO("session_manager.tcp_timeout_ms.handshake : %lu", cfg->tcp_timeout_ms.handshake); + SESSION_LOG_INFO("session_manager.tcp_timeout_ms.data : %lu", cfg->tcp_timeout_ms.data); + SESSION_LOG_INFO("session_manager.tcp_timeout_ms.half_closed : %lu", cfg->tcp_timeout_ms.half_closed); + SESSION_LOG_INFO("session_manager.tcp_timeout_ms.time_wait : %lu", cfg->tcp_timeout_ms.time_wait); + SESSION_LOG_INFO("session_manager.tcp_timeout_ms.discard_default : %lu", cfg->tcp_timeout_ms.discard_default); + SESSION_LOG_INFO("session_manager.tcp_timeout_ms.unverified_rst : %lu", cfg->tcp_timeout_ms.unverified_rst); // 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); + SESSION_LOG_INFO("session_manager.udp_timeout_ms.data : %lu", cfg->udp_timeout_ms.data); + SESSION_LOG_INFO("session_manager.udp_timeout_ms.discard_default : %lu", cfg->udp_timeout_ms.discard_default); // 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); + SESSION_LOG_INFO("session_manager.expire_period_ms : %lu", cfg->expire_period_ms); + SESSION_LOG_INFO("session_manager.expire_batch_max : %lu", cfg->expire_batch_max); // 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); + SESSION_LOG_INFO("session_manager.duplicated_packet_bloom_filter.enable : %d", cfg->duplicated_packet_bloom_filter.enable); + SESSION_LOG_INFO("session_manager.duplicated_packet_bloom_filter.capacity : %lu", cfg->duplicated_packet_bloom_filter.capacity); + SESSION_LOG_INFO("session_manager.duplicated_packet_bloom_filter.time_window_ms : %lu", cfg->duplicated_packet_bloom_filter.time_window_ms); + SESSION_LOG_INFO("session_manager.duplicated_packet_bloom_filter.error_rate : %f", cfg->duplicated_packet_bloom_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); + SESSION_LOG_INFO("session_manager.evicted_session_bloom_filter.enable : %d", cfg->evicted_session_bloom_filter.enable); + SESSION_LOG_INFO("session_manager.evicted_session_bloom_filter.capacity : %lu", cfg->evicted_session_bloom_filter.capacity); + SESSION_LOG_INFO("session_manager.evicted_session_bloom_filter.time_window_ms : %lu", cfg->evicted_session_bloom_filter.time_window_ms); + SESSION_LOG_INFO("session_manager.evicted_session_bloom_filter.error_rate : %f", cfg->evicted_session_bloom_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); + SESSION_LOG_INFO("session_manager.tcp_reassembly.enable : %d", cfg->tcp_reassembly.enable); + SESSION_LOG_INFO("session_manager.tcp_reassembly.timeout_ms : %lu", cfg->tcp_reassembly.timeout_ms); + SESSION_LOG_INFO("session_manager.tcp_reassembly.buffered_segments_max : %lu", cfg->tcp_reassembly.buffered_segments_max); } } @@ -983,7 +895,7 @@ struct session_manager *session_manager_new(const struct session_manager_config } memcpy(&mgr->cfg, cfg, sizeof(struct session_manager_config)); - mgr->sess_pool = session_pool_new(mgr->cfg.max_tcp_session_num + mgr->cfg.max_udp_session_num); + mgr->sess_pool = session_pool_new(mgr->cfg.tcp_session_max + mgr->cfg.udp_session_max); mgr->tcp_sess_table = session_table_new(); mgr->udp_sess_table = session_table_new(); mgr->sess_timer = session_timer_new(now_ms); @@ -991,21 +903,21 @@ struct session_manager *session_manager_new(const struct session_manager_config { goto error; } - if (mgr->cfg.evicted_session_filter_enable) + if (mgr->cfg.evicted_session_bloom_filter.enable) { - 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); + mgr->evicte_sess_filter = session_filter_new(mgr->cfg.evicted_session_bloom_filter.capacity, + mgr->cfg.evicted_session_bloom_filter.time_window_ms, + mgr->cfg.evicted_session_bloom_filter.error_rate, now_ms); if (mgr->evicte_sess_filter == NULL) { goto error; } } - if (mgr->cfg.duplicated_packet_filter_enable) + if (mgr->cfg.duplicated_packet_bloom_filter.enable) { - 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); + mgr->dup_pkt_filter = packet_filter_new(mgr->cfg.duplicated_packet_bloom_filter.capacity, + mgr->cfg.duplicated_packet_bloom_filter.time_window_ms, + mgr->cfg.duplicated_packet_bloom_filter.error_rate, now_ms); if (mgr->dup_pkt_filter == NULL) { goto error; @@ -1046,11 +958,11 @@ void session_manager_free(struct session_manager *mgr) { session_manager_free_session(mgr, sess); } - if (mgr->cfg.evicted_session_filter_enable) + if (mgr->cfg.evicted_session_bloom_filter.enable) { session_filter_free(mgr->evicte_sess_filter); } - if (mgr->cfg.duplicated_packet_filter_enable) + if (mgr->cfg.duplicated_packet_bloom_filter.enable) { packet_filter_free(mgr->dup_pkt_filter); } @@ -1070,7 +982,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->cfg.duplicated_packet_filter_enable) + if (mgr->cfg.duplicated_packet_bloom_filter.enable) { packet_filter_add(mgr->dup_pkt_filter, pkt, mgr->now_ms); } @@ -1255,10 +1167,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->cfg.tcp_data_timeout_ms); + session_timer_update(mgr->sess_timer, sess, now_ms + mgr->cfg.tcp_timeout_ms.data); break; case SESSION_TYPE_UDP: - session_timer_update(mgr->sess_timer, sess, now_ms + mgr->cfg.udp_data_timeout_ms); + session_timer_update(mgr->sess_timer, sess, now_ms + mgr->cfg.udp_timeout_ms.data); break; default: assert(0); @@ -1294,7 +1206,7 @@ uint64_t session_manager_clean_session(struct session_manager *mgr, uint64_t now 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) + if (now_ms - mgr->last_clean_expired_sess_ts >= mgr->cfg.expire_period_ms) { expired_sess_canbe_clean = 1; } @@ -1310,7 +1222,7 @@ uint64_t session_manager_clean_session(struct session_manager *mgr, uint64_t now // then clean expired session else { - if (expired_sess_canbe_clean && expired_sess_num < mgr->cfg.session_expire_polling_limit) + if (expired_sess_canbe_clean && expired_sess_num < mgr->cfg.expire_batch_max) { mgr->last_clean_expired_sess_ts = now_ms; sess = session_manager_get_expired_session(mgr, now_ms); @@ -1356,11 +1268,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->cfg.tcp_discard_timeout_ms); + session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->cfg.tcp_timeout_ms.discard_default); 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->cfg.udp_discard_timeout_ms); + session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->cfg.udp_timeout_ms.discard_default); SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, udp); break; default: diff --git a/infra/session_manager/session_manager.h b/infra/session_manager/session_manager.h index 89434f3..4b58c21 100644 --- a/infra/session_manager/session_manager.h +++ b/infra/session_manager/session_manager.h @@ -10,46 +10,54 @@ extern "C" struct session_manager_config { - // max session number - uint64_t max_tcp_session_num; - uint64_t max_udp_session_num; + uint64_t tcp_session_max; + uint64_t udp_session_max; - // session overload - uint8_t tcp_overload_evict_old_sess; // 1: evict old session, 0: bypass new session - uint8_t udp_overload_evict_old_sess; // 1: evict old session, 0: bypass new session + uint8_t evict_old_on_tcp_table_limit; // range: [0, 1] + uint8_t evict_old_on_udp_table_limit; // range: [0, 1] - // TCP timeout - 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_ms; // range: [1, 15999999000] (ms) - uint64_t udp_discard_timeout_ms; // range: [1, 15999999000] (ms) + uint64_t expire_period_ms; // range: [0, 60000] (ms) + uint64_t expire_batch_max; // range: [1, 1024] - // limit - uint64_t session_expire_polling_interval_ms; // range: [0, 60000] (ms) - uint64_t session_expire_polling_limit; // range: [1, 1024] + struct + { + uint64_t init; // range: [1, 60000] (ms) + uint64_t handshake; // range: [1, 60000] (ms) + uint64_t data; // range: [1, 15999999000] (ms) + uint64_t half_closed; // range: [1, 604800000] (ms) + uint64_t time_wait; // range: [1, 600000] (ms) + uint64_t discard_default; // range: [1, 15999999000] (ms) + uint64_t unverified_rst; // range: [1, 600000] (ms) + } tcp_timeout_ms; - // duplicate packet filter - uint8_t duplicated_packet_filter_enable; - 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] + struct + { + uint64_t data; // range: [1, 15999999000] (ms) + uint64_t discard_default; // range: [1, 15999999000] (ms) + } udp_timeout_ms; - // evicted session filter - uint8_t evicted_session_filter_enable; - 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] + struct + { + uint8_t enable; // range: [0, 1] + uint32_t capacity; // range: [1, 4294967295] + uint32_t time_window_ms; // range: [1, 60000] (ms) + double error_rate; // range: [0.0, 1.0] + } duplicated_packet_bloom_filter; - // TCP reassembly - uint8_t tcp_reassembly_enable; - uint32_t tcp_reassembly_max_timeout_ms; // range: [1, 60000] (ms) - uint32_t tcp_reassembly_max_segments; // range: [2, 512] + struct + { + uint8_t enable; // range: [0, 1] + uint32_t capacity; // range: [1, 4294967295] + uint32_t time_window_ms; // range: [1, 60000] (ms) + double error_rate; // range: [0.0, 1.0] + } evicted_session_bloom_filter; + + struct + { + uint8_t enable; // range: [0, 1] + uint32_t timeout_ms; // range: [1, 60000] (ms) + uint32_t buffered_segments_max; // range: [2, 512] + } tcp_reassembly; }; struct __attribute__((aligned(64))) session_manager_stat diff --git a/infra/session_manager/test/default_config.h b/infra/session_manager/test/default_config.h new file mode 100644 index 0000000..f949a8f --- /dev/null +++ b/infra/session_manager/test/default_config.h @@ -0,0 +1,65 @@ + + +#pragma once + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include "session_manager.h" + +static struct session_manager_config cfg = { + .tcp_session_max = 256, + .udp_session_max = 256, + + .evict_old_on_tcp_table_limit = 1, + .evict_old_on_udp_table_limit = 1, + + .expire_period_ms = 0, + .expire_batch_max = 1024, + + .tcp_timeout_ms = + { + .init = 1, + .handshake = 2, + .data = 3, + .half_closed = 4, + .time_wait = 5, + .discard_default = 6, + .unverified_rst = 7, + }, + + .udp_timeout_ms = + { + .data = 8, + .discard_default = 0, + }, + + .duplicated_packet_bloom_filter = + { + .enable = 1, + .capacity = 1000, + .time_window_ms = 10, + .error_rate = 0.0001, + }, + + .evicted_session_bloom_filter = + { + .enable = 1, + .capacity = 1000, + .time_window_ms = 10, + .error_rate = 0.0001, + }, + + .tcp_reassembly = + { + .enable = 1, + .timeout_ms = 1000, + .buffered_segments_max = 16, + }, +}; + +#ifdef __cplusplus +} +#endif diff --git a/infra/session_manager/test/gtest_case_tcp_fast_open.cpp b/infra/session_manager/test/gtest_case_tcp_fast_open.cpp index 55ea792..1894b6b 100644 --- a/infra/session_manager/test/gtest_case_tcp_fast_open.cpp +++ b/infra/session_manager/test/gtest_case_tcp_fast_open.cpp @@ -4,51 +4,7 @@ #include "packet_private.h" #include "packet_parser.h" #include "session_private.h" -#include "session_manager.h" - -struct session_manager_config cfg = { - // max session number - .max_tcp_session_num = 256, - .max_udp_session_num = 256, - - // session overload - .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_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_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_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_ms = 10, - .evicted_session_filter_error_rate = 0.0001, - - // TCP Reassembly - .tcp_reassembly_enable = 1, - .tcp_reassembly_max_timeout_ms = 60000, - .tcp_reassembly_max_segments = 16, -}; +#include "default_config.h" static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused))) { @@ -406,8 +362,8 @@ TEST(CASE, TCP_FAST_OPEN) EXPECT_TRUE(stat->tcp_sess_closing == 0); // expire session - 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(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL); // opening -> closing + sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data); // 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); diff --git a/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp b/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp index 9bb3fa2..0c53a90 100644 --- a/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp +++ b/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp @@ -3,53 +3,9 @@ #include "packet_private.h" #include "packet_parser.h" #include "session_private.h" -#include "session_manager.h" +#include "default_config.h" #include "test_packets.h" -struct session_manager_config cfg = { - // max session number - .max_tcp_session_num = 256, - .max_udp_session_num = 256, - - // session overload - .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_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_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_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_ms = 10, - .evicted_session_filter_error_rate = 0.0001, - - // TCP Reassembly - .tcp_reassembly_enable = 1, - .tcp_reassembly_max_timeout_ms = 60000, - .tcp_reassembly_max_segments = 16, -}; - static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused))) { static uint64_t count = 0; @@ -292,7 +248,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP) struct session_manager_stat *stat = NULL; struct session_manager_config _cfg; memcpy(&_cfg, &cfg, sizeof(struct session_manager_config)); - _cfg.duplicated_packet_filter_enable = 0; + _cfg.duplicated_packet_bloom_filter.enable = 0; mgr = session_manager_new(&_cfg, 1); EXPECT_TRUE(mgr != NULL); @@ -343,7 +299,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP) struct session_manager_stat *stat = NULL; struct session_manager_config _cfg; memcpy(&_cfg, &cfg, sizeof(struct session_manager_config)); - _cfg.duplicated_packet_filter_enable = 0; + _cfg.duplicated_packet_bloom_filter.enable = 0; mgr = session_manager_new(&_cfg, 1); EXPECT_TRUE(mgr != NULL); diff --git a/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp b/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp index 9dbfe2b..663ec24 100644 --- a/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp +++ b/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp @@ -4,53 +4,9 @@ #include "packet_private.h" #include "packet_parser.h" #include "session_private.h" -#include "session_manager.h" +#include "default_config.h" #include "test_packets.h" -struct session_manager_config cfg = { - // max session number - .max_tcp_session_num = RX_BURST_MAX * 2, - .max_udp_session_num = RX_BURST_MAX * 2, - - // session overload - .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_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_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_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_ms = 10, - .evicted_session_filter_error_rate = 0.0001, - - // TCP Reassembly - .tcp_reassembly_enable = 1, - .tcp_reassembly_max_timeout_ms = 60000, - .tcp_reassembly_max_segments = 16, -}; - static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused))) { static uint64_t count = 0; @@ -71,8 +27,12 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS) struct packet pkt; struct session_manager *mgr = NULL; struct session_manager_stat *stat = NULL; + struct session_manager_config _cfg; + memcpy(&_cfg, &cfg, sizeof(struct session_manager_config)); + _cfg.tcp_session_max = RX_BURST_MAX * 2; + _cfg.udp_session_max = RX_BURST_MAX * 2; - mgr = session_manager_new(&cfg, 1); + mgr = session_manager_new(&_cfg, 1); EXPECT_TRUE(mgr != NULL); session_manager_set_session_id_generator(mgr, session_id_generator); @@ -83,15 +43,15 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS) printf("<= Packet Parse: done\n\n"); // new session - for (uint32_t i = 0; i < cfg.max_tcp_session_num; i++) + for (uint32_t i = 0; i < _cfg.tcp_session_max; 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", cfg.max_tcp_session_num); + printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max); stat = session_manager_stat(mgr); EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == cfg.max_tcp_session_num); + EXPECT_TRUE(stat->tcp_sess_used == _cfg.tcp_session_max); EXPECT_TRUE(stat->tcp_sess_opening == RX_BURST_MAX); EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(stat->tcp_sess_closing == 0); @@ -112,7 +72,9 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS) struct session_manager_stat *stat = NULL; struct session_manager_config _cfg; memcpy(&_cfg, &cfg, sizeof(struct session_manager_config)); - _cfg.tcp_overload_evict_old_sess = 0; + _cfg.tcp_session_max = RX_BURST_MAX * 2; + _cfg.udp_session_max = RX_BURST_MAX * 2; + _cfg.evict_old_on_tcp_table_limit = 0; mgr = session_manager_new(&_cfg, 1); EXPECT_TRUE(mgr != NULL); @@ -125,16 +87,16 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS) printf("<= Packet Parse: done\n\n"); // new session - for (uint32_t i = 0; i < cfg.max_tcp_session_num; i++) + for (uint32_t i = 0; i < _cfg.tcp_session_max; 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", cfg.max_tcp_session_num); + printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max); stat = session_manager_stat(mgr); EXPECT_TRUE(stat); - 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_used == _cfg.tcp_session_max); + EXPECT_TRUE(stat->tcp_sess_opening == _cfg.tcp_session_max); EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(stat->tcp_sess_closed == 0); @@ -145,15 +107,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, cfg.max_tcp_session_num + i); + packet_set_ip_src_addr(&pkt, _cfg.tcp_session_max + 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 == cfg.max_tcp_session_num); - EXPECT_TRUE(stat->tcp_sess_opening == cfg.max_tcp_session_num); + EXPECT_TRUE(stat->tcp_sess_used == _cfg.tcp_session_max); + EXPECT_TRUE(stat->tcp_sess_opening == _cfg.tcp_session_max); EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(stat->tcp_sess_closed == 0); diff --git a/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp b/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp index 2f15528..1ccb723 100644 --- a/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp +++ b/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp @@ -4,53 +4,9 @@ #include "packet_private.h" #include "packet_parser.h" #include "session_private.h" -#include "session_manager.h" +#include "default_config.h" #include "test_packets.h" -struct session_manager_config cfg = { - // max session number - .max_tcp_session_num = RX_BURST_MAX * 2, - .max_udp_session_num = RX_BURST_MAX * 2, - - // session overload - .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_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_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_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_ms = 10, - .evicted_session_filter_error_rate = 0.0001, - - // TCP Reassembly - .tcp_reassembly_enable = 1, - .tcp_reassembly_max_timeout_ms = 60000, - .tcp_reassembly_max_segments = 16, -}; - static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused))) { static uint64_t count = 0; @@ -72,8 +28,12 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS) struct session *sess = NULL; struct session_manager *mgr = NULL; struct session_manager_stat *stat = NULL; + struct session_manager_config _cfg; + memcpy(&_cfg, &cfg, sizeof(struct session_manager_config)); + _cfg.tcp_session_max = RX_BURST_MAX * 2; + _cfg.udp_session_max = RX_BURST_MAX * 2; - mgr = session_manager_new(&cfg, 1); + mgr = session_manager_new(&_cfg, 1); EXPECT_TRUE(mgr != NULL); session_manager_set_session_id_generator(mgr, session_id_generator); @@ -84,15 +44,15 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS) printf("<= Packet Parse: done\n\n"); // new session - for (uint32_t i = 0; i < cfg.max_udp_session_num; i++) + for (uint32_t i = 0; i < _cfg.udp_session_max; 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", cfg.max_udp_session_num); + printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max); stat = session_manager_stat(mgr); EXPECT_TRUE(stat); - EXPECT_TRUE(stat->udp_sess_used == cfg.max_udp_session_num); + EXPECT_TRUE(stat->udp_sess_used == _cfg.udp_session_max); EXPECT_TRUE(stat->udp_sess_opening == RX_BURST_MAX); EXPECT_TRUE(stat->udp_sess_active == 0); EXPECT_TRUE(stat->udp_sess_closing == 0); @@ -136,7 +96,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 + cfg.evicted_session_filter_timeout_ms)); + EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1 + _cfg.evicted_session_bloom_filter.time_window_ms)); printf("=> Session Manager: after evicted session timeout\n"); stat = session_manager_stat(mgr); EXPECT_TRUE(stat); @@ -161,7 +121,9 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS) struct session_manager_stat *stat = NULL; struct session_manager_config _cfg; memcpy(&_cfg, &cfg, sizeof(struct session_manager_config)); - _cfg.udp_overload_evict_old_sess = 0; + _cfg.tcp_session_max = RX_BURST_MAX * 2; + _cfg.udp_session_max = RX_BURST_MAX * 2; + _cfg.evict_old_on_udp_table_limit = 0; mgr = session_manager_new(&_cfg, 1); EXPECT_TRUE(mgr != NULL); @@ -174,16 +136,16 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS) printf("<= Packet Parse: done\n\n"); // new session - for (uint32_t i = 0; i < cfg.max_udp_session_num; i++) + for (uint32_t i = 0; i < _cfg.udp_session_max; 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", cfg.max_udp_session_num); + printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max); stat = session_manager_stat(mgr); EXPECT_TRUE(stat); - 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_used == _cfg.udp_session_max); + EXPECT_TRUE(stat->udp_sess_opening == _cfg.udp_session_max); EXPECT_TRUE(stat->udp_sess_active == 0); EXPECT_TRUE(stat->udp_sess_closing == 0); EXPECT_TRUE(stat->udp_sess_closed == 0); @@ -197,15 +159,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, cfg.max_udp_session_num + i); + packet_set_ip_src_addr(&pkt, _cfg.udp_session_max + 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 == cfg.max_udp_session_num); - EXPECT_TRUE(stat->udp_sess_opening == cfg.max_udp_session_num); + EXPECT_TRUE(stat->udp_sess_used == _cfg.udp_session_max); + EXPECT_TRUE(stat->udp_sess_opening == _cfg.udp_session_max); EXPECT_TRUE(stat->udp_sess_active == 0); EXPECT_TRUE(stat->udp_sess_closing == 0); EXPECT_TRUE(stat->udp_sess_closed == 0); diff --git a/infra/session_manager/test/gtest_sess_mgr_scan.cpp b/infra/session_manager/test/gtest_sess_mgr_scan.cpp index 5d353db..36f241a 100644 --- a/infra/session_manager/test/gtest_sess_mgr_scan.cpp +++ b/infra/session_manager/test/gtest_sess_mgr_scan.cpp @@ -1,55 +1,11 @@ #include #include "session_private.h" -#include "session_manager.h" #include "packet_private.h" #include "packet_parser.h" +#include "default_config.h" #include "test_packets.h" -struct session_manager_config cfg = { - // max session number - .max_tcp_session_num = 256, - .max_udp_session_num = 256, - - // session overload - .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_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_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_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_ms = 10, - .evicted_session_filter_error_rate = 0.0001, - - // TCP Reassembly - .tcp_reassembly_enable = 1, - .tcp_reassembly_max_timeout_ms = 60000, - .tcp_reassembly_max_segments = 16, -}; - static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused))) { static uint64_t count = 0; diff --git a/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp b/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp index 952852b..03e3ec5 100644 --- a/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp +++ b/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp @@ -3,53 +3,9 @@ #include "packet_private.h" #include "packet_parser.h" #include "session_private.h" -#include "session_manager.h" +#include "default_config.h" #include "test_packets.h" -struct session_manager_config cfg = { - // max session number - .max_tcp_session_num = 256, - .max_udp_session_num = 256, - - // session overload - .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_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_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_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_ms = 10, - .evicted_session_filter_error_rate = 0.0001, - - // TCP Reassembly - .tcp_reassembly_enable = 1, - .tcp_reassembly_max_timeout_ms = 60000, - .tcp_reassembly_max_segments = 16, -}; - static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused))) { static uint64_t count = 0; @@ -249,8 +205,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 + 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(session_manager_get_expired_session(mgr, 7 + cfg.tcp_timeout_ms.data) == NULL); // active -> closing + sess = session_manager_get_expired_session(mgr, 7 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); // 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); @@ -343,8 +299,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 + 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(session_manager_get_expired_session(mgr, 4 + cfg.tcp_timeout_ms.data) == NULL); // active -> closing + sess = session_manager_get_expired_session(mgr, 4 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); // 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); diff --git a/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp b/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp index 60cbbbe..40e3f7d 100644 --- a/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp +++ b/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp @@ -5,53 +5,9 @@ #include "packet_private.h" #include "packet_parser.h" #include "session_private.h" -#include "session_manager.h" +#include "default_config.h" #include "test_packets.h" -struct session_manager_config cfg = { - // max session number - .max_tcp_session_num = 256, - .max_udp_session_num = 256, - - // session overload - .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_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_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_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_ms = 10, - .evicted_session_filter_error_rate = 0.0001, - - // TCP Reassembly - .tcp_reassembly_enable = 1, - .tcp_reassembly_max_timeout_ms = 60000, - .tcp_reassembly_max_segments = 16, -}; - static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused))) { static uint64_t count = 0; @@ -159,7 +115,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 + cfg.tcp_time_wait_timeout_ms); + sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.time_wait); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); @@ -245,7 +201,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 + cfg.tcp_unverified_rst_timeout_ms); + sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.unverified_rst); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST); @@ -331,7 +287,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 + cfg.tcp_unverified_rst_timeout_ms); + sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.unverified_rst); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST); @@ -378,8 +334,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 + 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(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); @@ -459,7 +415,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 + cfg.tcp_half_closed_timeout_ms); + sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.half_closed); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); @@ -539,7 +495,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 + cfg.tcp_half_closed_timeout_ms); + sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.half_closed); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN); diff --git a/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp b/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp index 6434a3b..1395072 100644 --- a/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp +++ b/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp @@ -5,53 +5,9 @@ #include "packet_private.h" #include "packet_parser.h" #include "session_private.h" -#include "session_manager.h" +#include "default_config.h" #include "test_packets.h" -struct session_manager_config cfg = { - // max session number - .max_tcp_session_num = 256, - .max_udp_session_num = 256, - - // session overload - .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_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_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_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_ms = 10, - .evicted_session_filter_error_rate = 0.0001, - - // TCP Reassembly - .tcp_reassembly_enable = 1, - .tcp_reassembly_max_timeout_ms = 60000, - .tcp_reassembly_max_segments = 16, -}; - static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused))) { static uint64_t count = 0; @@ -115,8 +71,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 + 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(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL); // opening -> closing + sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data); // 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); @@ -193,8 +149,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 + 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(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake) == NULL); + sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); @@ -283,8 +239,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 + 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(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake) == NULL); + sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); @@ -385,8 +341,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 + 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(session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); @@ -482,8 +438,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 + 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(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.init) == NULL); + sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); @@ -580,8 +536,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 + 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(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake) == NULL); + sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); @@ -670,8 +626,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 + 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(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); @@ -760,8 +716,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 + 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(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); diff --git a/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp b/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp index 4d569e7..61b0c70 100644 --- a/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp +++ b/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp @@ -5,53 +5,9 @@ #include "packet_private.h" #include "packet_parser.h" #include "session_private.h" -#include "session_manager.h" +#include "default_config.h" #include "test_packets.h" -struct session_manager_config cfg = { - // max session number - .max_tcp_session_num = 256, - .max_udp_session_num = 256, - - // session overload - .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_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_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_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_ms = 10, - .evicted_session_filter_error_rate = 0.0001, - - // TCP Reassembly - .tcp_reassembly_enable = 1, - .tcp_reassembly_max_timeout_ms = 60000, - .tcp_reassembly_max_segments = 16, -}; - static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused))) { static uint64_t count = 0; @@ -421,7 +377,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 + cfg.tcp_time_wait_timeout_ms); + sess = session_manager_get_expired_session(mgr, 11 + cfg.tcp_timeout_ms.time_wait); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); diff --git a/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp b/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp index 1e5f533..f12717e 100644 --- a/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp +++ b/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp @@ -5,53 +5,9 @@ #include "packet_private.h" #include "packet_parser.h" #include "session_private.h" -#include "session_manager.h" +#include "default_config.h" #include "test_packets.h" -struct session_manager_config cfg = { - // max session number - .max_tcp_session_num = 256, - .max_udp_session_num = 256, - - // session overload - .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_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_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_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_ms = 10, - .evicted_session_filter_error_rate = 0.0001, - - // TCP Reassembly - .tcp_reassembly_enable = 1, - .tcp_reassembly_max_timeout_ms = 60000, - .tcp_reassembly_max_segments = 16, -}; - static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused))) { static uint64_t count = 0; @@ -127,8 +83,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 + 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(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); @@ -217,8 +173,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 + 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(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); diff --git a/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp b/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp index a0951f8..06f8cbb 100644 --- a/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp +++ b/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp @@ -5,53 +5,9 @@ #include "packet_private.h" #include "packet_parser.h" #include "session_private.h" -#include "session_manager.h" +#include "default_config.h" #include "test_packets.h" -struct session_manager_config cfg = { - // max session number - .max_tcp_session_num = 256, - .max_udp_session_num = 256, - - // session overload - .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_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_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_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_ms = 10, - .evicted_session_filter_error_rate = 0.0001, - - // TCP Reassembly - .tcp_reassembly_enable = 1, - .tcp_reassembly_max_timeout_ms = 60000, - .tcp_reassembly_max_segments = 16, -}; - static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused))) { static uint64_t count = 0; @@ -139,7 +95,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 + cfg.tcp_time_wait_timeout_ms); + sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.time_wait); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); @@ -234,7 +190,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 + cfg.tcp_unverified_rst_timeout_ms); + sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.unverified_rst); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST); @@ -329,7 +285,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 + cfg.tcp_unverified_rst_timeout_ms); + sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.unverified_rst); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST); @@ -386,8 +342,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 + 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(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL); + sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); @@ -476,8 +432,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 + 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(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake) == NULL); + sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); @@ -578,8 +534,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 + 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(session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); @@ -668,7 +624,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 + cfg.tcp_half_closed_timeout_ms); + sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.half_closed); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); @@ -757,7 +713,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 + cfg.tcp_half_closed_timeout_ms); + sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.half_closed); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN); diff --git a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp index 41ee468..0ecd250 100644 --- a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp +++ b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp @@ -5,53 +5,9 @@ #include "packet_private.h" #include "packet_parser.h" #include "session_private.h" -#include "session_manager.h" +#include "default_config.h" #include "test_packets.h" -struct session_manager_config cfg = { - // max session number - .max_tcp_session_num = 256, - .max_udp_session_num = 256, - - // session overload - .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_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_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_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_ms = 10, - .evicted_session_filter_error_rate = 0.0001, - - // TCP Reassembly - .tcp_reassembly_enable = 1, - .tcp_reassembly_max_timeout_ms = 60000, - .tcp_reassembly_max_segments = 16, -}; - static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused))) { static uint64_t count = 0; @@ -141,8 +97,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 + 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(session_manager_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data) == NULL); // active -> closing + sess = session_manager_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // 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); diff --git a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp index 06dae39..6b513cd 100644 --- a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp +++ b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp @@ -5,53 +5,9 @@ #include "packet_private.h" #include "packet_parser.h" #include "session_private.h" -#include "session_manager.h" +#include "default_config.h" #include "test_packets.h" -struct session_manager_config cfg = { - // max session number - .max_tcp_session_num = 256, - .max_udp_session_num = 256, - - // session overload - .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_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_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_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_ms = 10, - .evicted_session_filter_error_rate = 0.0001, - - // TCP Reassembly - .tcp_reassembly_enable = 1, - .tcp_reassembly_max_timeout_ms = 60000, - .tcp_reassembly_max_segments = 16, -}; - static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused))) { static uint64_t count = 0; @@ -116,8 +72,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 + 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(session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data) == NULL); // opening -> closing + sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // 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); @@ -195,8 +151,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 + 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(session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data) == NULL); // opening -> closing + sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // closing -> closed EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); diff --git a/infra/session_manager/test/gtest_timeout_tcp_data.cpp b/infra/session_manager/test/gtest_timeout_tcp_data.cpp index 0582b7b..c337bc1 100644 --- a/infra/session_manager/test/gtest_timeout_tcp_data.cpp +++ b/infra/session_manager/test/gtest_timeout_tcp_data.cpp @@ -4,53 +4,9 @@ #include "packet_private.h" #include "packet_parser.h" #include "session_private.h" -#include "session_manager.h" +#include "default_config.h" #include "test_packets.h" -struct session_manager_config cfg = { - // max session number - .max_tcp_session_num = 256, - .max_udp_session_num = 256, - - // session overload - .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_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_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_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_ms = 10, - .evicted_session_filter_error_rate = 0.0001, - - // TCP Reassembly - .tcp_reassembly_enable = 1, - .tcp_reassembly_max_timeout_ms = 60000, - .tcp_reassembly_max_segments = 16, -}; - static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused))) { static uint64_t count = 0; @@ -93,8 +49,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 + 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(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); diff --git a/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp b/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp index 4ea2e62..74c3edd 100644 --- a/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp +++ b/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp @@ -4,53 +4,9 @@ #include "packet_private.h" #include "packet_parser.h" #include "session_private.h" -#include "session_manager.h" +#include "default_config.h" #include "test_packets.h" -struct session_manager_config cfg = { - // max session number - .max_tcp_session_num = 256, - .max_udp_session_num = 256, - - // session overload - .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_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_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_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_ms = 10, - .evicted_session_filter_error_rate = 0.0001, - - // TCP Reassembly - .tcp_reassembly_enable = 1, - .tcp_reassembly_max_timeout_ms = 60000, - .tcp_reassembly_max_segments = 16, -}; - static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused))) { static uint64_t count = 0; @@ -81,8 +37,8 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE) EXPECT_TRUE(sess); // expire session - 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(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake) == NULL); + sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); diff --git a/infra/session_manager/test/gtest_timeout_tcp_init.cpp b/infra/session_manager/test/gtest_timeout_tcp_init.cpp index f0136a2..c5e83e2 100644 --- a/infra/session_manager/test/gtest_timeout_tcp_init.cpp +++ b/infra/session_manager/test/gtest_timeout_tcp_init.cpp @@ -4,53 +4,9 @@ #include "packet_private.h" #include "packet_parser.h" #include "session_private.h" -#include "session_manager.h" +#include "default_config.h" #include "test_packets.h" -struct session_manager_config cfg = { - // max session number - .max_tcp_session_num = 256, - .max_udp_session_num = 256, - - // session overload - .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_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_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_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_ms = 10, - .evicted_session_filter_error_rate = 0.0001, - - // TCP Reassembly - .tcp_reassembly_enable = 1, - .tcp_reassembly_max_timeout_ms = 60000, - .tcp_reassembly_max_segments = 16, -}; - static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused))) { static uint64_t count = 0; @@ -81,8 +37,8 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT) EXPECT_TRUE(sess); // expire session - 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(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL); // opening -> closing + sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data); // 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); diff --git a/infra/session_manager/test/gtest_timeout_udp_data.cpp b/infra/session_manager/test/gtest_timeout_udp_data.cpp index 94c8e13..78645a1 100644 --- a/infra/session_manager/test/gtest_timeout_udp_data.cpp +++ b/infra/session_manager/test/gtest_timeout_udp_data.cpp @@ -4,53 +4,9 @@ #include "packet_private.h" #include "packet_parser.h" #include "session_private.h" -#include "session_manager.h" +#include "default_config.h" #include "test_packets.h" -struct session_manager_config cfg = { - // max session number - .max_tcp_session_num = 256, - .max_udp_session_num = 256, - - // session overload - .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_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_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_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_ms = 10, - .evicted_session_filter_error_rate = 0.0001, - - // TCP Reassembly - .tcp_reassembly_enable = 1, - .tcp_reassembly_max_timeout_ms = 60000, - .tcp_reassembly_max_segments = 16, -}; - static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused))) { static uint64_t count = 0; @@ -81,8 +37,8 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1) EXPECT_TRUE(sess); // expire session - 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(session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data) == NULL); // opening -> closing + sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // 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); @@ -130,8 +86,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 + 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(session_manager_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data) == NULL); // active -> closing + sess = session_manager_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // 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); diff --git a/test/decoders/http/test_based_on_stellar/env/stellar.toml b/test/decoders/http/test_based_on_stellar/env/stellar.toml index b472a69..d741b1c 100644 --- a/test/decoders/http/test_based_on_stellar/env/stellar.toml +++ b/test/decoders/http/test_based_on_stellar/env/stellar.toml @@ -1,67 +1,65 @@ [snowflake] -snowflake_base = 1 # [0, 31] -snowflake_offset = 2 # [0, 127] + snowflake_base = 1 # [0, 31] + snowflake_offset = 2 # [0, 127] [packet_io] -mode = "pcapfile" # pcapfile, pcaplist, marsio -app_symbol = "stellar" -dev_symbol = "nf_0_fw" -pcap_path = "./pcap/test.pcap" -nr_worker_thread = 1 # range: [1, 256] -cpu_mask = [5, 6, 7, 8, 9, 10, 11, 12] -idle_yield_interval_ms = 900 # range: [0, 60000] (ms) + mode = "pcapfile" # pcapfile, pcaplist, marsio + app_symbol = "stellar" + dev_symbol = "nf_0_fw" + pcap_path = "./pcap/test.pcap" + nr_worker_thread = 1 # range: [1, 256] + cpu_mask = [5, 6, 7, 8, 9, 10, 11, 12] + idle_yield_interval_ms = 900 # range: [0, 60000] (ms) [ip_reassembly] -enable = 1 -bucket_entries = 32 # range: [1, 4294967295] (must be power of 2) -bucket_num = 1024 # range: [1, 4294967295] + enable = 1 + bucket_entries = 32 # range: [1, 4294967295] (must be power of 2) + bucket_num = 1024 # range: [1, 4294967295] -ip_frag_timeout_ms = 10000 # range: [1, 60000] (ms) -ip_frag_expire_polling_interval_ms = 0 # range: [0, 60000] (ms) -ip_frag_expire_polling_limit = 1024 # range: [1, 1024] + ip_frag_timeout_ms = 10000 # range: [1, 60000] (ms) + ip_frag_expire_polling_interval_ms = 0 # range: [0, 60000] (ms) + ip_frag_expire_polling_limit = 1024 # range: [1, 1024] [session_manager] -# max session number -max_tcp_session_num = 50000 -max_udp_session_num = 50000 + tcp_session_max = 50000 + udp_session_max = 50000 -# session overload evict -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 + evict_old_on_tcp_table_limit = 1 # range: [0, 1] + evict_old_on_udp_table_limit = 1 # range: [0, 1] -# TCP timeout -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_ms = 50 # range: [1, 15999999000] (ms) -udp_discard_timeout_ms = 50 # range: [1, 15999999000] (ms) + expire_period_ms = 0 # range: [0, 60000] (ms) + expire_batch_max = 1024 # range: [1, 1024] -# limit -session_expire_polling_interval_ms = 0 # range: [0, 60000] (ms) -session_expire_polling_limit = 1024 # range: [1, 1024] + [session_manager.tcp_timeout_ms] + init = 5000 # range: [1, 60000] (ms) + handshake = 5000 # range: [1, 60000] (ms) + data = 5000 # range: [1, 15999999000] (ms) + half_closed = 5000 # range: [1, 604800000] (ms) + time_wait = 5000 # range: [1, 600000] (ms) + discard_default = 10000 # range: [1, 15999999000] (ms) + unverified_rst = 5000 # range: [1, 600000] (ms) -# duplicate packet filter -duplicated_packet_filter_enable = 1 -duplicated_packet_filter_capacity = 1000000 # range: [1, 4294967295] -duplicated_packet_filter_timeout_ms = 10000 # range: [1, 60000] (ms) -duplicated_packet_filter_error_rate = 0.00001 # range: [0.0, 1.0] + [session_manager.udp_timeout_ms] + data = 5000 # range: [1, 15999999000] (ms) + discard_default = 5000 # range: [1, 15999999000] (ms) -# evicted session filter -evicted_session_filter_enable = 1 -evicted_session_filter_capacity = 1000000 # range: [1, 4294967295] -evicted_session_filter_timeout_ms = 10000 # range: [1, 60000] (ms) -evicted_session_filter_error_rate = 0.00001 # range: [0.0, 1.0] + [session_manager.duplicated_packet_bloom_filter] + enable = 1 + capacity = 1000000 # range: [1, 4294967295] + time_window_ms = 10000 # range: [1, 60000] (ms) + error_rate = 0.00001 # range: [0.0, 1.0] -# TCP reassembly (Per direction) -tcp_reassembly_enable = 1 -tcp_reassembly_max_timeout_ms = 10000 # range: [1, 60000] (ms) -tcp_reassembly_max_segments = 256 # range: [2, 4096] + [session_manager.evicted_session_bloom_filter] + enable = 1 # range: [0, 1] + capacity = 1000000 # range: [1, 4294967295] + time_window_ms = 10000 # range: [1, 60000] (ms) + error_rate = 0.00001 # range: [0.0, 1.0] + + [session_manager.tcp_reassembly] + enable = 1 # range: [0, 1] + timeout_ms = 10000 # range: [1, 60000] (ms) + buffered_segments_max = 256 # range: [2, 4096] per flow [schedule] -merge_stat_interval = 50 # range: [1, 60000] (ms) -output_stat_interval = 10 # range: [1, 60000] (ms) + merge_stat_interval = 500 # range: [1, 60000] (ms) + output_stat_interval = 2000 # range: [1, 60000] (ms) diff --git a/test/packet_inject/conf/stellar.toml b/test/packet_inject/conf/stellar.toml index 4791358..ee4c8cb 100644 --- a/test/packet_inject/conf/stellar.toml +++ b/test/packet_inject/conf/stellar.toml @@ -1,67 +1,65 @@ [snowflake] -snowflake_base = 1 # [0, 31] -snowflake_offset = 2 # [0, 127] + snowflake_base = 1 # [0, 31] + snowflake_offset = 2 # [0, 127] [packet_io] -mode = "pcapfile" # pcapfile, pcaplist, marsio -app_symbol = "stellar" -dev_symbol = "nf_0_fw" -pcap_path = "/tmp/test.pcap" -nr_worker_thread = 1 # range: [1, 256] -cpu_mask = [5] -idle_yield_interval_ms = 900 # range: [0, 60000] (ms) + mode = "pcapfile" # pcapfile, pcaplist, marsio + app_symbol = "stellar" + dev_symbol = "nf_0_fw" + pcap_path = "/tmp/test.pcap" + nr_worker_thread = 1 # range: [1, 256] + cpu_mask = [5, 6, 7, 8, 9, 10, 11, 12] + idle_yield_interval_ms = 900 # range: [0, 60000] (ms) [ip_reassembly] -enable = 1 -bucket_entries = 32 # range: [1, 4294967295] (must be power of 2) -bucket_num = 1024 # range: [1, 4294967295] + enable = 1 + bucket_entries = 32 # range: [1, 4294967295] (must be power of 2) + bucket_num = 1024 # range: [1, 4294967295] -ip_frag_timeout_ms = 10000 # range: [1, 60000] (ms) -ip_frag_expire_polling_interval_ms = 0 # range: [0, 60000] (ms) -ip_frag_expire_polling_limit = 1024 # range: [1, 1024] + ip_frag_timeout_ms = 10000 # range: [1, 60000] (ms) + ip_frag_expire_polling_interval_ms = 0 # range: [0, 60000] (ms) + ip_frag_expire_polling_limit = 1024 # range: [1, 1024] [session_manager] -# max session number -max_tcp_session_num = 50000 -max_udp_session_num = 50000 + tcp_session_max = 50000 + udp_session_max = 50000 -# session overload evict -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 + evict_old_on_tcp_table_limit = 1 # range: [0, 1] + evict_old_on_udp_table_limit = 1 # range: [0, 1] -# TCP timeout -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_ms = 50 # range: [1, 15999999000] (ms) -udp_discard_timeout_ms = 50 # range: [1, 15999999000] (ms) + expire_period_ms = 0 # range: [0, 60000] (ms) + expire_batch_max = 1024 # range: [1, 1024] -# limit -session_expire_polling_interval_ms = 0 # range: [0, 60000] (ms) -session_expire_polling_limit = 1024 # range: [1, 1024] + [session_manager.tcp_timeout_ms] + init = 5000 # range: [1, 60000] (ms) + handshake = 5000 # range: [1, 60000] (ms) + data = 5000 # range: [1, 15999999000] (ms) + half_closed = 5000 # range: [1, 604800000] (ms) + time_wait = 5000 # range: [1, 600000] (ms) + discard_default = 10000 # range: [1, 15999999000] (ms) + unverified_rst = 5000 # range: [1, 600000] (ms) -# duplicate packet filter -duplicated_packet_filter_enable = 1 -duplicated_packet_filter_capacity = 1000000 # range: [1, 4294967295] -duplicated_packet_filter_timeout_ms = 100 # range: [1, 60000] (ms) -duplicated_packet_filter_error_rate = 0.00001 # range: [0.0, 1.0] + [session_manager.udp_timeout_ms] + data = 5000 # range: [1, 15999999000] (ms) + discard_default = 5000 # range: [1, 15999999000] (ms) -# evicted session filter -evicted_session_filter_enable = 1 -evicted_session_filter_capacity = 1000000 # range: [1, 4294967295] -evicted_session_filter_timeout_ms = 100 # range: [1, 60000] (ms) -evicted_session_filter_error_rate = 0.00001 # range: [0.0, 1.0] + [session_manager.duplicated_packet_bloom_filter] + enable = 1 + capacity = 1000000 # range: [1, 4294967295] + time_window_ms = 10000 # range: [1, 60000] (ms) + error_rate = 0.00001 # range: [0.0, 1.0] -# TCP reassembly (Per direction) -tcp_reassembly_enable = 1 -tcp_reassembly_max_timeout_ms = 10000 # range: [1, 60000] (ms) -tcp_reassembly_max_segments = 128 # range: [2, 4096] + [session_manager.evicted_session_bloom_filter] + enable = 1 # range: [0, 1] + capacity = 1000000 # range: [1, 4294967295] + time_window_ms = 10000 # range: [1, 60000] (ms) + error_rate = 0.00001 # range: [0.0, 1.0] + + [session_manager.tcp_reassembly] + enable = 1 # range: [0, 1] + timeout_ms = 10000 # range: [1, 60000] (ms) + buffered_segments_max = 256 # range: [2, 4096] per flow [schedule] -merge_stat_interval = 50 # range: [1, 60000] (ms) -output_stat_interval = 2000 # range: [1, 60000] (ms) + merge_stat_interval = 500 # range: [1, 60000] (ms) + output_stat_interval = 2000 # range: [1, 60000] (ms)