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

optimize session manager config

Browse Source
This commit is contained in:
luwenpeng
2024-08-30 18:33:41 +08:00
parent d1d5e6e09e
commit 82cb1eaeeb
26 changed files with 632 additions and 1319 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
conf/stellar.toml
View File

@@ -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)

140
infra/core/utils.h
View File

@@ -5,9 +5,15 @@ extern "C"
{
#endif
#include <stdint.h>
#include <stdio.h>
#include <time.h>
#include <errno.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#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

96
infra/ip_reassembly/ip_reassembly.c
View File

@@ -4,10 +4,9 @@
#include <sys/queue.h>
#include <assert.h>
#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;

10
infra/packet_io/packet_io.c
View File

@@ -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)
{

294
infra/session_manager/session_manager.c
View File

@@ -4,8 +4,6 @@
#include <errno.h>
#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:

76
infra/session_manager/session_manager.h
View File

@@ -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

65
infra/session_manager/test/default_config.h Normal file
View File

@@ -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

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

@@ -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);

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

@@ -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);

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

@@ -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);

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

@@ -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);

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

@@ -1,55 +1,11 @@
#include <gtest/gtest.h>
#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;

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

@@ -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);

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

@@ -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);

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

@@ -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);

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

@@ -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);

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

@@ -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);

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

@@ -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);

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

@@ -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);

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

@@ -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);

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

@@ -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);

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

@@ -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);

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

@@ -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);

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

@@ -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);

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

@@ -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)

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

@@ -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)