diff options
| author | luwenpeng <[email protected]> | 2024-09-18 18:32:20 +0800 |
|---|---|---|
| committer | luwenpeng <[email protected]> | 2024-09-20 16:59:19 +0800 |
| commit | 620019cf8e1c2be20a478ff8572bb0a9c22ddf3c (patch) | |
| tree | 8b5da36f7e89e722fb97d3812cbeb12e4ff591cc | |
| parent | 60caf1bda19f8797b72ef93a9c18517c4ca9495c (diff) | |
refactor(session manager): rename original session_manager to session_manager_runtime
26 files changed, 1670 insertions, 1585 deletions
diff --git a/infra/ip_reassembly/ip_reassembly.h b/infra/ip_reassembly/ip_reassembly.h index 269b320..a9b95ee 100644 --- a/infra/ip_reassembly/ip_reassembly.h +++ b/infra/ip_reassembly/ip_reassembly.h @@ -16,7 +16,7 @@ struct ip_reassembly_config uint64_t ip_frag_expire_polling_limit; // range: [1, 1024] }; -struct __attribute__((aligned(64))) ip_reassembly_stat +struct ip_reassembly_stat { // IPv4 frag stat uint64_t ip4_defrags_expected; @@ -47,7 +47,7 @@ struct __attribute__((aligned(64))) ip_reassembly_stat uint64_t ip6_frags_bypass_no_buffer; uint64_t ip6_frags_bypass_dup_fist_frag; uint64_t ip6_frags_bypass_dup_last_frag; -}; +} __attribute__((aligned(64))); struct ip_reassembly_config *ip_reassembly_config_new(const char *toml_file); void ip_reassembly_config_free(struct ip_reassembly_config *cfg); diff --git a/infra/packet_io/packet_io.h b/infra/packet_io/packet_io.h index 8754bed..5b677e8 100644 --- a/infra/packet_io/packet_io.h +++ b/infra/packet_io/packet_io.h @@ -10,7 +10,7 @@ extern "C" #include "utils.h" -struct __attribute__((aligned(64))) packet_io_stat +struct packet_io_stat { // device packet uint64_t pkts_rx; @@ -44,7 +44,7 @@ struct __attribute__((aligned(64))) packet_io_stat uint64_t ctrl_pkts_tx; uint64_t ctrl_bytes_tx; -}; +} __attribute__((aligned(64))); enum packet_io_mode { diff --git a/infra/packet_manager/packet_manager_private.h b/infra/packet_manager/packet_manager_private.h new file mode 100644 index 0000000..4fe6a36 --- /dev/null +++ b/infra/packet_manager/packet_manager_private.h @@ -0,0 +1,46 @@ +#pragma once + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include "stellar/packet_manager.h" + +#define PACKET_QUEUE_MAX (PACKET_STAGE_MAX + 1) + +struct packet_manager *packet_manager_new(struct mq_schema *mq_schema, const char *toml_file); +void packet_manager_free(struct packet_manager *pkt_mgr); + +void packet_manager_runtime_init(struct packet_manager_runtime *pkt_mgr_rt, struct mq_runtime *mq_rt); +void packet_manager_runtime_ingress(struct packet_manager_runtime *pkt_mgr_rt, struct packet *pkt); +struct packet *packet_manager_runtime_egress(struct packet_manager_runtime *pkt_mgr_rt); +void packet_manager_runtime_dispatch(struct packet_manager_runtime *pkt_mgr_rt); + +/****************************************************************************** + * for gtest + ******************************************************************************/ + +struct packet_manager_stat +{ + struct + { + uint64_t pkts_ingress; + uint64_t pkts_egress; + } total; + struct + { + uint64_t pkts_in; // include the packets that are scheduled + uint64_t pkts_out; // include the packets that are claimed + uint64_t pkts_claim; + uint64_t pkts_schedule; + } queue[PACKET_QUEUE_MAX]; // the last queue is for sending packets +} __attribute__((aligned(64))); + +const char *packet_stage_to_str(enum packet_stage stage); +void packet_manager_runtime_print_stat(struct packet_manager_runtime *runtime); +struct packet_manager_stat *packet_manager_runtime_get_stat(struct packet_manager_runtime *runtime); + +#ifdef __cplusplus +} +#endif diff --git a/infra/session_manager/session_internal.h b/infra/session_manager/session_internal.h index be0ef21..0ee8373 100644 --- a/infra/session_manager/session_internal.h +++ b/infra/session_manager/session_internal.h @@ -71,8 +71,8 @@ struct session enum session_type sess_type; enum session_state state; enum closing_reason reason; - struct session_manager *mgr; - struct session_manager_stat *mgr_stat; + struct session_manager_runtime *sess_mgr_rt; + struct session_manager_stat *sess_mgr_stat; }; TAILQ_HEAD(session_list, session); diff --git a/infra/session_manager/session_manager.c b/infra/session_manager/session_manager.c index 3025f22..c56258d 100644 --- a/infra/session_manager/session_manager.c +++ b/infra/session_manager/session_manager.c @@ -24,7 +24,7 @@ struct snowflake uint64_t sequence; }; -struct session_manager +struct session_manager_runtime { struct session_list evicte_list; struct session_pool *sess_pool; @@ -39,8 +39,8 @@ struct session_manager struct session_manager_config cfg; /* - * only used for session_set_discard() or session_manager record_duplicated_packet(), - * because the function is called by pluin and has no time input. + * only used for session_set_discard() or session_manager_runtime_record_duplicated_packet(), + * because the function is called by plugin and has no time input. */ uint64_t now_ms; uint64_t last_clean_expired_sess_ts; @@ -111,7 +111,7 @@ struct session_manager } /****************************************************************************** - * snowflake id generator + * snowflake ******************************************************************************/ static struct snowflake *snowflake_new(uint64_t seed) @@ -163,7 +163,7 @@ static uint64_t snowflake_generate(struct snowflake *sf, uint64_t now_sec) * TCP utils ******************************************************************************/ -static void tcp_clean(struct session_manager *mgr, struct session *sess) +static void tcp_clean(struct session_manager_runtime *sess_mgr_rt, struct session *sess) { struct tcp_reassembly *c2s_ssembler = sess->tcp_halfs[FLOW_TYPE_C2S].assembler; struct tcp_reassembly *s2c_ssembler = sess->tcp_halfs[FLOW_TYPE_S2C].assembler; @@ -174,7 +174,7 @@ static void tcp_clean(struct session_manager *mgr, struct session *sess) { session_inc_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_RELEASED, 1); session_inc_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_RELEASED, seg->len); - mgr->stat.tcp_segs_freed++; + sess_mgr_rt->stat.tcp_segs_freed++; tcp_segment_free(seg); } tcp_reassembly_free(c2s_ssembler); @@ -185,25 +185,25 @@ static void tcp_clean(struct session_manager *mgr, struct session *sess) { session_inc_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_RELEASED, 1); session_inc_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_RELEASED, seg->len); - mgr->stat.tcp_segs_freed++; + sess_mgr_rt->stat.tcp_segs_freed++; tcp_segment_free(seg); } tcp_reassembly_free(s2c_ssembler); } } -static int tcp_init(struct session_manager *mgr, struct session *sess) +static int tcp_init(struct session_manager_runtime *sess_mgr_rt, struct session *sess) { - if (!mgr->cfg.tcp_reassembly.enable) + if (!sess_mgr_rt->cfg.tcp_reassembly.enable) { return 0; } - sess->tcp_halfs[FLOW_TYPE_C2S].assembler = tcp_reassembly_new(mgr->cfg.tcp_reassembly.timeout_ms, mgr->cfg.tcp_reassembly.buffered_segments_max); - sess->tcp_halfs[FLOW_TYPE_S2C].assembler = tcp_reassembly_new(mgr->cfg.tcp_reassembly.timeout_ms, mgr->cfg.tcp_reassembly.buffered_segments_max); + sess->tcp_halfs[FLOW_TYPE_C2S].assembler = tcp_reassembly_new(sess_mgr_rt->cfg.tcp_reassembly.timeout_ms, sess_mgr_rt->cfg.tcp_reassembly.buffered_segments_max); + sess->tcp_halfs[FLOW_TYPE_S2C].assembler = tcp_reassembly_new(sess_mgr_rt->cfg.tcp_reassembly.timeout_ms, sess_mgr_rt->cfg.tcp_reassembly.buffered_segments_max); if (sess->tcp_halfs[FLOW_TYPE_C2S].assembler == NULL || sess->tcp_halfs[FLOW_TYPE_S2C].assembler == NULL) { - tcp_clean(mgr, sess); + tcp_clean(sess_mgr_rt, sess); return -1; } @@ -215,7 +215,7 @@ static int tcp_init(struct session_manager *mgr, struct session *sess) return 0; } -static void tcp_update(struct session_manager *mgr, struct session *sess, enum flow_type type, const struct layer_private *tcp_layer) +static void tcp_update(struct session_manager_runtime *sess_mgr_rt, struct session *sess, enum flow_type type, const struct layer_private *tcp_layer) { struct tcp_segment *seg; struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr; @@ -233,17 +233,17 @@ 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 (!sess_mgr_rt->cfg.tcp_reassembly.enable) { if (len) { session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RECEIVED, 1); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RECEIVED, len); - mgr->stat.tcp_segs_input++; + sess_mgr_rt->stat.tcp_segs_input++; session_inc_stat(sess, type, STAT_TCP_SEGMENTS_INORDER, 1); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_INORDER, len); - mgr->stat.tcp_segs_inorder++; + sess_mgr_rt->stat.tcp_segs_inorder++; half->in_order.data = tcp_layer->pld_ptr; half->in_order.len = len; @@ -258,16 +258,16 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f tcp_reassembly_set_recv_next(half->assembler, len ? half->seq : half->seq + 1); } - seg = tcp_reassembly_expire(half->assembler, mgr->now_ms); + seg = tcp_reassembly_expire(half->assembler, sess_mgr_rt->now_ms); if (seg) { session_inc_stat(sess, type, STAT_TCP_SEGMENTS_EXPIRED, 1); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_EXPIRED, seg->len); - mgr->stat.tcp_segs_timeout++; + sess_mgr_rt->stat.tcp_segs_timeout++; session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RELEASED, 1); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RELEASED, seg->len); - mgr->stat.tcp_segs_freed++; + sess_mgr_rt->stat.tcp_segs_freed++; tcp_segment_free(seg); } @@ -276,7 +276,7 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f { session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RECEIVED, 1); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RECEIVED, len); - mgr->stat.tcp_segs_input++; + sess_mgr_rt->stat.tcp_segs_input++; uint32_t rcv_nxt = tcp_reassembly_get_recv_next(half->assembler); // in order @@ -284,7 +284,7 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f { session_inc_stat(sess, type, STAT_TCP_SEGMENTS_INORDER, 1); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_INORDER, len); - mgr->stat.tcp_segs_inorder++; + sess_mgr_rt->stat.tcp_segs_inorder++; half->in_order.data = tcp_layer->pld_ptr; half->in_order.len = len; @@ -296,37 +296,37 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f { session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RETRANSMIT, 1); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RETRANSMIT, len); - mgr->stat.tcp_segs_retransmited++; + sess_mgr_rt->stat.tcp_segs_retransmited++; } else if ((seg = tcp_segment_new(half->seq, tcp_layer->pld_ptr, len))) { - switch (tcp_reassembly_push(half->assembler, seg, mgr->now_ms)) + switch (tcp_reassembly_push(half->assembler, seg, sess_mgr_rt->now_ms)) { case -2: session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RETRANSMIT, 1); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RETRANSMIT, len); - mgr->stat.tcp_segs_retransmited++; + sess_mgr_rt->stat.tcp_segs_retransmited++; tcp_segment_free(seg); break; case -1: session_inc_stat(sess, type, STAT_TCP_SEGMENTS_NOSPACE, 1); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_NOSPACE, len); - mgr->stat.tcp_segs_omitted_too_many++; + sess_mgr_rt->stat.tcp_segs_omitted_too_many++; tcp_segment_free(seg); break; case 0: session_inc_stat(sess, type, STAT_TCP_SEGMENTS_BUFFERED, 1); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_BUFFERED, len); - mgr->stat.tcp_segs_buffered++; + sess_mgr_rt->stat.tcp_segs_buffered++; break; case 1: session_inc_stat(sess, type, STAT_TCP_SEGMENTS_OVERLAP, 1); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_OVERLAP, len); - mgr->stat.tcp_segs_overlapped++; + sess_mgr_rt->stat.tcp_segs_overlapped++; session_inc_stat(sess, type, STAT_TCP_SEGMENTS_BUFFERED, 1); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_BUFFERED, len); - mgr->stat.tcp_segs_buffered++; + sess_mgr_rt->stat.tcp_segs_buffered++; break; default: assert(0); @@ -337,13 +337,13 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f { session_inc_stat(sess, type, STAT_TCP_SEGMENTS_NOSPACE, 1); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_NOSPACE, len); - mgr->stat.tcp_segs_omitted_too_many++; + sess_mgr_rt->stat.tcp_segs_omitted_too_many++; } } } /****************************************************************************** - * session direction identify + * session flow ******************************************************************************/ static enum flow_type identify_flow_type_by_port(uint16_t src_port, uint16_t dst_port) @@ -377,45 +377,43 @@ static enum flow_type identify_flow_type_by_history(const struct session *sess, } /****************************************************************************** - * session filter bypass utils + * bypass packet -- table limit / session evicted / duplicated packet ******************************************************************************/ -// on new session -static int tcp_overload_bypass(struct session_manager *mgr, const struct tuple6 *key) +static int session_manager_runtime_bypass_packet_on_tcp_table_limit(struct session_manager_runtime *sess_mgr_rt, const struct tuple6 *key) { - if (key->ip_proto == IPPROTO_TCP && mgr->stat.tcp_sess_used >= mgr->cfg.tcp_session_max) + if (key->ip_proto == IPPROTO_TCP && sess_mgr_rt->stat.tcp_sess_used >= sess_mgr_rt->cfg.tcp_session_max) { - mgr->stat.tcp_pkts_bypass_table_full++; + sess_mgr_rt->stat.tcp_pkts_bypass_table_full++; return 1; } return 0; } -static int udp_overload_bypass(struct session_manager *mgr, const struct tuple6 *key) +static int session_manager_runtime_bypass_packet_on_udp_table_limit(struct session_manager_runtime *sess_mgr_rt, const struct tuple6 *key) { - if (key->ip_proto == IPPROTO_UDP && mgr->stat.udp_sess_used >= mgr->cfg.udp_session_max) + if (key->ip_proto == IPPROTO_UDP && sess_mgr_rt->stat.udp_sess_used >= sess_mgr_rt->cfg.udp_session_max) { - mgr->stat.udp_pkts_bypass_table_full++; + sess_mgr_rt->stat.udp_pkts_bypass_table_full++; return 1; } return 0; } -static int evicted_session_bypass(struct session_manager *mgr, const struct tuple6 *key) +static int session_manager_runtime_bypass_packet_on_session_evicted(struct session_manager_runtime *sess_mgr_rt, const struct tuple6 *key) { - if (mgr->cfg.evicted_session_bloom_filter.enable && session_filter_lookup(mgr->evicte_sess_filter, key, mgr->now_ms)) + if (sess_mgr_rt->cfg.evicted_session_bloom_filter.enable && session_filter_lookup(sess_mgr_rt->evicte_sess_filter, key, sess_mgr_rt->now_ms)) { - mgr->stat.udp_pkts_bypass_session_evicted++; + sess_mgr_rt->stat.udp_pkts_bypass_session_evicted++; return 1; } return 0; } -// on update session -static int duplicated_packet_bypass(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key) +static int session_manager_runtime_bypass_duplicated_packet(struct session_manager_runtime *sess_mgr_rt, struct session *sess, const struct packet *pkt, const struct tuple6 *key) { - if (mgr->cfg.duplicated_packet_bloom_filter.enable == 0) + if (sess_mgr_rt->cfg.duplicated_packet_bloom_filter.enable == 0) { return 0; } @@ -423,17 +421,17 @@ static int duplicated_packet_bypass(struct session_manager *mgr, struct session enum flow_type type = identify_flow_type_by_history(sess, key); if (session_get_stat(sess, type, STAT_RAW_PACKETS_RECEIVED) < 3 || session_has_duplicate_traffic(sess)) { - if (packet_filter_lookup(mgr->dup_pkt_filter, pkt, mgr->now_ms)) + if (packet_filter_lookup(sess_mgr_rt->dup_pkt_filter, pkt, sess_mgr_rt->now_ms)) { session_inc_stat(sess, type, STAT_DUPLICATE_PACKETS_BYPASS, 1); session_inc_stat(sess, type, STAT_DUPLICATE_BYTES_BYPASS, packet_get_raw_len(pkt)); switch (session_get_type(sess)) { case SESSION_TYPE_TCP: - mgr->stat.tcp_pkts_bypass_duplicated++; + sess_mgr_rt->stat.tcp_pkts_bypass_duplicated++; break; case SESSION_TYPE_UDP: - mgr->stat.udp_pkts_bypass_duplicated++; + sess_mgr_rt->stat.udp_pkts_bypass_duplicated++; break; default: assert(0); @@ -447,7 +445,7 @@ static int duplicated_packet_bypass(struct session_manager *mgr, struct session } else { - packet_filter_add(mgr->dup_pkt_filter, pkt, mgr->now_ms); + packet_filter_add(sess_mgr_rt->dup_pkt_filter, pkt, sess_mgr_rt->now_ms); return 0; } } @@ -455,15 +453,239 @@ static int duplicated_packet_bypass(struct session_manager *mgr, struct session return 0; } +void session_manager_runtime_record_duplicated_packet(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt) +{ + if (sess_mgr_rt->cfg.duplicated_packet_bloom_filter.enable) + { + packet_filter_add(sess_mgr_rt->dup_pkt_filter, pkt, sess_mgr_rt->now_ms); + } +} + +/****************************************************************************** + * config -- new / free / print + ******************************************************************************/ + +struct session_manager_config *session_manager_config_new(const char *toml_file) +{ + if (toml_file == NULL) + { + return NULL; + } + + struct session_manager_config *sess_mgr_cfg = (struct session_manager_config *)calloc(1, sizeof(struct session_manager_config)); + if (sess_mgr_cfg == NULL) + { + return NULL; + } + + int ret = 0; + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.tcp_session_max", (uint64_t *)&sess_mgr_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 *)&sess_mgr_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 *)&sess_mgr_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 *)&sess_mgr_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 *)&sess_mgr_cfg->expire_period_ms, 0, 60000); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.expire_batch_max", (uint64_t *)&sess_mgr_cfg->expire_batch_max, 1, 1024); + + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.init", (uint64_t *)&sess_mgr_cfg->tcp_timeout_ms.init, 1, 60000); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.handshake", (uint64_t *)&sess_mgr_cfg->tcp_timeout_ms.handshake, 1, 60000); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.data", (uint64_t *)&sess_mgr_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 *)&sess_mgr_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 *)&sess_mgr_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 *)&sess_mgr_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 *)&sess_mgr_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 *)&sess_mgr_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 *)&sess_mgr_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 *)&sess_mgr_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 *)&sess_mgr_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 *)&sess_mgr_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 *)&sess_mgr_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 *)&sess_mgr_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 *)&sess_mgr_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 *)&sess_mgr_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 *)&sess_mgr_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 *)&sess_mgr_cfg->tcp_reassembly.enable, 0, 1); + ret += load_and_validate_toml_integer_config(toml_file, "session_manager.tcp_reassembly.timeout_ms", (uint64_t *)&sess_mgr_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 *)&sess_mgr_cfg->tcp_reassembly.buffered_segments_max, 1, 512); + + if (ret != 0) + { + session_manager_config_free(sess_mgr_cfg); + return NULL; + } + + return sess_mgr_cfg; +} + +void session_manager_config_free(struct session_manager_config *sess_mgr_cfg) +{ + if (sess_mgr_cfg) + { + free(sess_mgr_cfg); + sess_mgr_cfg = NULL; + } +} + +void session_manager_config_print(struct session_manager_config *sess_mgr_cfg) +{ + if (sess_mgr_cfg) + { + // max session number + SESSION_LOG_INFO("session_manager.tcp_session_max : %lu", sess_mgr_cfg->tcp_session_max); + SESSION_LOG_INFO("session_manager.udp_session_max : %lu", sess_mgr_cfg->udp_session_max); + + // session overload + SESSION_LOG_INFO("session_manager.evict_old_on_tcp_table_limit : %d", sess_mgr_cfg->evict_old_on_tcp_table_limit); + SESSION_LOG_INFO("session_manager.evict_old_on_udp_table_limit : %d", sess_mgr_cfg->evict_old_on_udp_table_limit); + + // TCP timeout + SESSION_LOG_INFO("session_manager.tcp_timeout_ms.init : %lu", sess_mgr_cfg->tcp_timeout_ms.init); + SESSION_LOG_INFO("session_manager.tcp_timeout_ms.handshake : %lu", sess_mgr_cfg->tcp_timeout_ms.handshake); + SESSION_LOG_INFO("session_manager.tcp_timeout_ms.data : %lu", sess_mgr_cfg->tcp_timeout_ms.data); + SESSION_LOG_INFO("session_manager.tcp_timeout_ms.half_closed : %lu", sess_mgr_cfg->tcp_timeout_ms.half_closed); + SESSION_LOG_INFO("session_manager.tcp_timeout_ms.time_wait : %lu", sess_mgr_cfg->tcp_timeout_ms.time_wait); + SESSION_LOG_INFO("session_manager.tcp_timeout_ms.discard_default : %lu", sess_mgr_cfg->tcp_timeout_ms.discard_default); + SESSION_LOG_INFO("session_manager.tcp_timeout_ms.unverified_rst : %lu", sess_mgr_cfg->tcp_timeout_ms.unverified_rst); + + // UDP timeout + SESSION_LOG_INFO("session_manager.udp_timeout_ms.data : %lu", sess_mgr_cfg->udp_timeout_ms.data); + SESSION_LOG_INFO("session_manager.udp_timeout_ms.discard_default : %lu", sess_mgr_cfg->udp_timeout_ms.discard_default); + + // limit + SESSION_LOG_INFO("session_manager.expire_period_ms : %lu", sess_mgr_cfg->expire_period_ms); + SESSION_LOG_INFO("session_manager.expire_batch_max : %lu", sess_mgr_cfg->expire_batch_max); + + // duplicated packet filter + SESSION_LOG_INFO("session_manager.duplicated_packet_bloom_filter.enable : %d", sess_mgr_cfg->duplicated_packet_bloom_filter.enable); + SESSION_LOG_INFO("session_manager.duplicated_packet_bloom_filter.capacity : %lu", sess_mgr_cfg->duplicated_packet_bloom_filter.capacity); + SESSION_LOG_INFO("session_manager.duplicated_packet_bloom_filter.time_window_ms : %lu", sess_mgr_cfg->duplicated_packet_bloom_filter.time_window_ms); + SESSION_LOG_INFO("session_manager.duplicated_packet_bloom_filter.error_rate : %f", sess_mgr_cfg->duplicated_packet_bloom_filter.error_rate); + + // eviction session filter + SESSION_LOG_INFO("session_manager.evicted_session_bloom_filter.enable : %d", sess_mgr_cfg->evicted_session_bloom_filter.enable); + SESSION_LOG_INFO("session_manager.evicted_session_bloom_filter.capacity : %lu", sess_mgr_cfg->evicted_session_bloom_filter.capacity); + SESSION_LOG_INFO("session_manager.evicted_session_bloom_filter.time_window_ms : %lu", sess_mgr_cfg->evicted_session_bloom_filter.time_window_ms); + SESSION_LOG_INFO("session_manager.evicted_session_bloom_filter.error_rate : %f", sess_mgr_cfg->evicted_session_bloom_filter.error_rate); + + // TCP reassembly + SESSION_LOG_INFO("session_manager.tcp_reassembly.enable : %d", sess_mgr_cfg->tcp_reassembly.enable); + SESSION_LOG_INFO("session_manager.tcp_reassembly.timeout_ms : %lu", sess_mgr_cfg->tcp_reassembly.timeout_ms); + SESSION_LOG_INFO("session_manager.tcp_reassembly.buffered_segments_max : %lu", sess_mgr_cfg->tcp_reassembly.buffered_segments_max); + } +} + +/****************************************************************************** + * runtime -- new / free + ******************************************************************************/ + +struct session_manager_runtime *session_manager_runtime_new(const struct session_manager_config *sess_mgr_cfg, uint64_t now_ms) +{ + struct session_manager_runtime *sess_mgr_rt = (struct session_manager_runtime *)calloc(1, sizeof(struct session_manager_runtime)); + if (sess_mgr_rt == NULL) + { + return NULL; + } + memcpy(&sess_mgr_rt->cfg, sess_mgr_cfg, sizeof(struct session_manager_config)); + + sess_mgr_rt->sess_pool = session_pool_new(sess_mgr_rt->cfg.tcp_session_max + sess_mgr_rt->cfg.udp_session_max); + sess_mgr_rt->tcp_sess_table = session_table_new(); + sess_mgr_rt->udp_sess_table = session_table_new(); + sess_mgr_rt->sess_timer = session_timer_new(now_ms); + if (sess_mgr_rt->sess_pool == NULL || sess_mgr_rt->tcp_sess_table == NULL || sess_mgr_rt->udp_sess_table == NULL || sess_mgr_rt->sess_timer == NULL) + { + goto error; + } + if (sess_mgr_rt->cfg.evicted_session_bloom_filter.enable) + { + sess_mgr_rt->evicte_sess_filter = session_filter_new(sess_mgr_rt->cfg.evicted_session_bloom_filter.capacity, + sess_mgr_rt->cfg.evicted_session_bloom_filter.time_window_ms, + sess_mgr_rt->cfg.evicted_session_bloom_filter.error_rate, now_ms); + if (sess_mgr_rt->evicte_sess_filter == NULL) + { + goto error; + } + } + if (sess_mgr_rt->cfg.duplicated_packet_bloom_filter.enable) + { + sess_mgr_rt->dup_pkt_filter = packet_filter_new(sess_mgr_rt->cfg.duplicated_packet_bloom_filter.capacity, + sess_mgr_rt->cfg.duplicated_packet_bloom_filter.time_window_ms, + sess_mgr_rt->cfg.duplicated_packet_bloom_filter.error_rate, now_ms); + if (sess_mgr_rt->dup_pkt_filter == NULL) + { + goto error; + } + } + sess_mgr_rt->sf = snowflake_new(sess_mgr_rt->cfg.session_id_seed); + if (sess_mgr_rt->sf == NULL) + { + goto error; + } + + TAILQ_INIT(&sess_mgr_rt->evicte_list); + session_transition_init(); + sess_mgr_rt->now_ms = now_ms; + sess_mgr_rt->last_clean_expired_sess_ts = now_ms; + + return sess_mgr_rt; + +error: + session_manager_runtime_free(sess_mgr_rt); + return NULL; +} + +void session_manager_runtime_free(struct session_manager_runtime *sess_mgr_rt) +{ + struct session *sess; + if (sess_mgr_rt) + { + // free all evicted session + while ((sess = TAILQ_FIRST(&sess_mgr_rt->evicte_list))) + { + TAILQ_REMOVE(&sess_mgr_rt->evicte_list, sess, evicte_tqe); + session_manager_runtime_free_session(sess_mgr_rt, sess); + } + // free all udp session + while (sess_mgr_rt->udp_sess_table && (sess = session_table_find_lru(sess_mgr_rt->udp_sess_table))) + { + session_manager_runtime_free_session(sess_mgr_rt, sess); + } + // free all tcp session + while (sess_mgr_rt->tcp_sess_table && (sess = session_table_find_lru(sess_mgr_rt->tcp_sess_table))) + { + session_manager_runtime_free_session(sess_mgr_rt, sess); + } + if (sess_mgr_rt->cfg.evicted_session_bloom_filter.enable) + { + session_filter_free(sess_mgr_rt->evicte_sess_filter); + } + if (sess_mgr_rt->cfg.duplicated_packet_bloom_filter.enable) + { + packet_filter_free(sess_mgr_rt->dup_pkt_filter); + } + snowflake_free(sess_mgr_rt->sf); + session_timer_free(sess_mgr_rt->sess_timer); + session_table_free(sess_mgr_rt->udp_sess_table); + session_table_free(sess_mgr_rt->tcp_sess_table); + session_pool_free(sess_mgr_rt->sess_pool); + free(sess_mgr_rt); + sess_mgr_rt = NULL; + } +} + /****************************************************************************** - * session manager utils + * session -- new / free / lookup / updata / expire / evicte / clean ******************************************************************************/ -static void session_update(struct session_manager *mgr, struct session *sess, enum session_state next_state, const struct packet *pkt, const struct tuple6 *key, enum flow_type type) +static void session_update(struct session_manager_runtime *sess_mgr_rt, struct session *sess, enum session_state next_state, const struct packet *pkt, const struct tuple6 *key, enum flow_type type) { if (session_get_current_state(sess) == SESSION_STATE_INIT) { - uint64_t sess_id = snowflake_generate(mgr->sf, mgr->now_ms / 1000); + uint64_t sess_id = snowflake_generate(sess_mgr_rt->sf, sess_mgr_rt->now_ms / 1000); session_set_id(sess, sess_id); enum packet_direction pkt_dir = packet_get_direction(pkt); if (type == FLOW_TYPE_C2S) @@ -495,7 +717,7 @@ static void session_update(struct session_manager *mgr, struct session *sess, en tuple6_to_str(&out, sess->tuple_str, sizeof(sess->tuple_str)); } - session_set_timestamp(sess, SESSION_TIMESTAMP_START, mgr->now_ms); + session_set_timestamp(sess, SESSION_TIMESTAMP_START, sess_mgr_rt->now_ms); switch (key->ip_proto) { case IPPROTO_TCP: @@ -522,11 +744,11 @@ static void session_update(struct session_manager *mgr, struct session *sess, en session_set_current_packet(sess, pkt); session_set_flow_type(sess, type); - session_set_timestamp(sess, SESSION_TIMESTAMP_LAST, mgr->now_ms); + session_set_timestamp(sess, SESSION_TIMESTAMP_LAST, sess_mgr_rt->now_ms); session_set_current_state(sess, next_state); } -static void session_manager_evicte_session(struct session_manager *mgr, struct session *sess, int reason) +static void session_manager_runtime_evicte_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess, int reason) { if (sess == NULL) { @@ -549,26 +771,26 @@ static void session_manager_evicte_session(struct session_manager *mgr, struct s session_set_closing_reason(sess, CLOSING_BY_LRU_EVICTED); } } - session_timer_del(mgr->sess_timer, sess); - TAILQ_INSERT_TAIL(&mgr->evicte_list, sess, evicte_tqe); + session_timer_del(sess_mgr_rt->sess_timer, sess); + TAILQ_INSERT_TAIL(&sess_mgr_rt->evicte_list, sess, evicte_tqe); switch (session_get_type(sess)) { case SESSION_TYPE_TCP: SESSION_LOG_DEBUG("evicte tcp old session: %lu", session_get_id(sess)); - session_table_del(mgr->tcp_sess_table, sess); - SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, tcp); - mgr->stat.tcp_sess_evicted++; + session_table_del(sess_mgr_rt->tcp_sess_table, sess); + SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, tcp); + sess_mgr_rt->stat.tcp_sess_evicted++; break; 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_bloom_filter.enable) + session_table_del(sess_mgr_rt->udp_sess_table, sess); + if (sess_mgr_rt->cfg.evicted_session_bloom_filter.enable) { - session_filter_add(mgr->evicte_sess_filter, session_get_tuple6(sess), mgr->now_ms); + session_filter_add(sess_mgr_rt->evicte_sess_filter, session_get_tuple6(sess), sess_mgr_rt->now_ms); } - SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, udp); - mgr->stat.udp_sess_evicted++; + SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, udp); + sess_mgr_rt->stat.udp_sess_evicted++; break; default: assert(0); @@ -576,9 +798,9 @@ static void session_manager_evicte_session(struct session_manager *mgr, struct s } } -static struct session *session_manager_lookup_tcp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key) +static struct session *session_manager_runtime_lookup_tcp_session(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt, const struct tuple6 *key) { - struct session *sess = session_table_find_tuple6(mgr->tcp_sess_table, key, 0); + struct session *sess = session_table_find_tuple6(sess_mgr_rt->tcp_sess_table, key, 0); if (sess == NULL) { return NULL; @@ -598,7 +820,7 @@ static struct session *session_manager_lookup_tcp_session(struct session_manager ((half->history & TH_FIN) || (half->history & TH_RST))) // recv SYN after FIN or RST { // TCP port reuse, evict old session - session_manager_evicte_session(mgr, sess, PORT_REUSE_EVICT); + session_manager_runtime_evicte_session(sess_mgr_rt, sess, PORT_REUSE_EVICT); return NULL; } else @@ -608,98 +830,98 @@ static struct session *session_manager_lookup_tcp_session(struct session_manager } } -static struct session *session_manager_new_tcp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key) +static struct session *session_manager_runtime_new_tcp_session(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt, const struct tuple6 *key) { const struct layer_private *tcp_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_TCP); const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr; uint8_t flags = tcp_hdr_get_flags(hdr); if (!(flags & TH_SYN)) { - mgr->stat.tcp_pkts_bypass_session_not_found++; + sess_mgr_rt->stat.tcp_pkts_bypass_session_not_found++; return NULL; } // tcp table full evict old session - if (mgr->cfg.evict_old_on_tcp_table_limit && mgr->stat.tcp_sess_used >= mgr->cfg.tcp_session_max - EVICTE_SESSION_BURST) + if (sess_mgr_rt->cfg.evict_old_on_tcp_table_limit && sess_mgr_rt->stat.tcp_sess_used >= sess_mgr_rt->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); + struct session *evic_sess = session_table_find_lru(sess_mgr_rt->tcp_sess_table); + session_manager_runtime_evicte_session(sess_mgr_rt, evic_sess, LRU_EVICT); } enum flow_type type = (flags & TH_ACK) ? FLOW_TYPE_S2C : FLOW_TYPE_C2S; - struct session *sess = session_pool_pop(mgr->sess_pool); + struct session *sess = session_pool_pop(sess_mgr_rt->sess_pool); if (sess == NULL) { assert(0); return NULL; } session_init(sess); - sess->mgr = mgr; - sess->mgr_stat = &mgr->stat; + sess->sess_mgr_rt = sess_mgr_rt; + sess->sess_mgr_stat = &sess_mgr_rt->stat; enum session_state next_state = session_transition_run(SESSION_STATE_INIT, TCP_SYN); - session_update(mgr, sess, next_state, pkt, key, type); + session_update(sess_mgr_rt, sess, next_state, pkt, key, type); session_transition_log(sess, SESSION_STATE_INIT, next_state, TCP_SYN); - if (tcp_init(mgr, sess) == -1) + if (tcp_init(sess_mgr_rt, sess) == -1) { assert(0); - session_pool_push(mgr->sess_pool, sess); + session_pool_push(sess_mgr_rt->sess_pool, sess); return NULL; } - tcp_update(mgr, sess, type, tcp_layer); + tcp_update(sess_mgr_rt, sess, type, tcp_layer); - 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); + uint64_t timeout = (flags & TH_ACK) ? sess_mgr_rt->cfg.tcp_timeout_ms.handshake : sess_mgr_rt->cfg.tcp_timeout_ms.init; + session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + timeout); + session_table_add(sess_mgr_rt->tcp_sess_table, sess); - if (mgr->cfg.duplicated_packet_bloom_filter.enable) + if (sess_mgr_rt->cfg.duplicated_packet_bloom_filter.enable) { - packet_filter_add(mgr->dup_pkt_filter, pkt, mgr->now_ms); + packet_filter_add(sess_mgr_rt->dup_pkt_filter, pkt, sess_mgr_rt->now_ms); } - SESS_MGR_STAT_INC(&mgr->stat, next_state, tcp); - mgr->stat.tcp_sess_used++; - mgr->stat.history_tcp_sessions++; + SESS_MGR_STAT_INC(&sess_mgr_rt->stat, next_state, tcp); + sess_mgr_rt->stat.tcp_sess_used++; + sess_mgr_rt->stat.history_tcp_sessions++; return sess; } -static struct session *session_manager_new_udp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key) +static struct session *session_manager_runtime_new_udp_session(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt, const struct tuple6 *key) { // udp table full evict old session - if (mgr->cfg.evict_old_on_udp_table_limit && mgr->stat.udp_sess_used >= mgr->cfg.udp_session_max - EVICTE_SESSION_BURST) + if (sess_mgr_rt->cfg.evict_old_on_udp_table_limit && sess_mgr_rt->stat.udp_sess_used >= sess_mgr_rt->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); + struct session *evic_sess = session_table_find_lru(sess_mgr_rt->udp_sess_table); + session_manager_runtime_evicte_session(sess_mgr_rt, evic_sess, LRU_EVICT); } - struct session *sess = session_pool_pop(mgr->sess_pool); + struct session *sess = session_pool_pop(sess_mgr_rt->sess_pool); if (sess == NULL) { assert(sess); return NULL; } session_init(sess); - sess->mgr = mgr; - sess->mgr_stat = &mgr->stat; + sess->sess_mgr_rt = sess_mgr_rt; + sess->sess_mgr_stat = &sess_mgr_rt->stat; enum flow_type type = identify_flow_type_by_port(ntohs(key->src_port), ntohs(key->dst_port)); enum session_state next_state = session_transition_run(SESSION_STATE_INIT, UDP_DATA); - session_update(mgr, sess, next_state, pkt, key, type); + session_update(sess_mgr_rt, sess, next_state, pkt, key, type); session_transition_log(sess, SESSION_STATE_INIT, next_state, UDP_DATA); - session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->cfg.udp_timeout_ms.data); - session_table_add(mgr->udp_sess_table, sess); + session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + sess_mgr_rt->cfg.udp_timeout_ms.data); + session_table_add(sess_mgr_rt->udp_sess_table, sess); - SESS_MGR_STAT_INC(&mgr->stat, next_state, udp); - mgr->stat.udp_sess_used++; - mgr->stat.history_udp_sessions++; + SESS_MGR_STAT_INC(&sess_mgr_rt->stat, next_state, udp); + sess_mgr_rt->stat.udp_sess_used++; + sess_mgr_rt->stat.history_udp_sessions++; return sess; } -static int session_manager_update_tcp_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key) +static int session_manager_runtime_update_tcp_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess, const struct packet *pkt, const struct tuple6 *key) { const struct layer_private *tcp_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_TCP); const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr; @@ -716,11 +938,11 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc enum session_state next_state = session_transition_run(curr_state, inputs); // update session - session_update(mgr, sess, next_state, pkt, key, type); + session_update(sess_mgr_rt, sess, next_state, pkt, key, type); session_transition_log(sess, curr_state, next_state, inputs); // update tcp - tcp_update(mgr, sess, type, tcp_layer); + tcp_update(sess_mgr_rt, sess, type, tcp_layer); // set closing reason if (next_state == SESSION_STATE_CLOSING && !session_get_closing_reason(sess)) @@ -744,301 +966,71 @@ 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_timeout_ms.handshake : mgr->cfg.tcp_timeout_ms.init; + timeout = (flags & TH_ACK) ? sess_mgr_rt->cfg.tcp_timeout_ms.handshake : sess_mgr_rt->cfg.tcp_timeout_ms.init; } else { - timeout = mgr->cfg.tcp_timeout_ms.data; + timeout = sess_mgr_rt->cfg.tcp_timeout_ms.data; } break; case SESSION_STATE_ACTIVE: - timeout = mgr->cfg.tcp_timeout_ms.data; + timeout = sess_mgr_rt->cfg.tcp_timeout_ms.data; break; case SESSION_STATE_CLOSING: if (flags & TH_FIN) { - timeout = (peer->history & TH_FIN) ? mgr->cfg.tcp_timeout_ms.time_wait : mgr->cfg.tcp_timeout_ms.half_closed; + timeout = (peer->history & TH_FIN) ? sess_mgr_rt->cfg.tcp_timeout_ms.time_wait : sess_mgr_rt->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_timeout_ms.time_wait : mgr->cfg.tcp_timeout_ms.unverified_rst; + timeout = (expected == curr->seq) ? sess_mgr_rt->cfg.tcp_timeout_ms.time_wait : sess_mgr_rt->cfg.tcp_timeout_ms.unverified_rst; } else { - timeout = mgr->cfg.tcp_timeout_ms.data; + timeout = sess_mgr_rt->cfg.tcp_timeout_ms.data; } break; case SESSION_STATE_DISCARD: - timeout = mgr->cfg.tcp_timeout_ms.discard_default; + timeout = sess_mgr_rt->cfg.tcp_timeout_ms.discard_default; break; default: assert(0); break; } - session_timer_update(mgr->sess_timer, sess, mgr->now_ms + timeout); + session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + timeout); - SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, tcp); + SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, tcp); return 0; } -static int session_manager_update_udp_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key) +static int session_manager_runtime_update_udp_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess, const struct packet *pkt, const struct tuple6 *key) { enum flow_type type = identify_flow_type_by_history(sess, key); enum session_state curr_state = session_get_current_state(sess); enum session_state next_state = session_transition_run(curr_state, UDP_DATA); - session_update(mgr, sess, next_state, pkt, key, type); + session_update(sess_mgr_rt, sess, next_state, pkt, key, type); session_transition_log(sess, curr_state, next_state, UDP_DATA); if (session_get_current_state(sess) == SESSION_STATE_DISCARD) { - session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->cfg.udp_timeout_ms.discard_default); + session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + sess_mgr_rt->cfg.udp_timeout_ms.discard_default); } else { - session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->cfg.udp_timeout_ms.data); + session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + sess_mgr_rt->cfg.udp_timeout_ms.data); } - SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, udp); + SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, udp); return 0; } -static inline uint8_t ipv4_in_range(const struct in_addr *addr, const struct in_addr *start, const struct in_addr *end) -{ - return (memcmp(addr, start, sizeof(struct in_addr)) >= 0 && memcmp(addr, end, sizeof(struct in_addr)) <= 0); -} - -static inline uint8_t ipv6_in_range(const struct in6_addr *addr, const struct in6_addr *start, const struct in6_addr *end) +struct session *session_manager_runtime_new_session(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt, uint64_t now_ms) { - return (memcmp(addr, start, sizeof(struct in6_addr)) >= 0 && memcmp(addr, end, sizeof(struct in6_addr)) <= 0); -} - -/****************************************************************************** - * session manager public API - ******************************************************************************/ - -struct session_manager_config *session_manager_config_new(const char *toml_file) -{ - if (toml_file == NULL) - { - return NULL; - } - - struct session_manager_config *cfg = (struct session_manager_config *)calloc(1, sizeof(struct session_manager_config)); - if (cfg == NULL) - { - return NULL; - } - - 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; - } - - return cfg; -} - -void session_manager_config_free(struct session_manager_config *cfg) -{ - if (cfg) - { - free(cfg); - cfg = NULL; - } -} - -void session_manager_config_print(struct session_manager_config *cfg) -{ - if (cfg) - { - // max session number - SESSION_LOG_INFO("session_manager.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.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_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_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.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_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_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.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); - } -} - -struct session_manager *session_manager_new(const struct session_manager_config *cfg, uint64_t now_ms) -{ - struct session_manager *mgr = (struct session_manager *)calloc(1, sizeof(struct session_manager)); - if (mgr == NULL) - { - return NULL; - } - memcpy(&mgr->cfg, cfg, sizeof(struct session_manager_config)); - - 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); - if (mgr->sess_pool == NULL || mgr->tcp_sess_table == NULL || mgr->udp_sess_table == NULL || mgr->sess_timer == NULL) - { - goto error; - } - if (mgr->cfg.evicted_session_bloom_filter.enable) - { - 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_bloom_filter.enable) - { - 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; - } - } - mgr->sf = snowflake_new(mgr->cfg.session_id_seed); - if (mgr->sf == NULL) - { - goto error; - } - - TAILQ_INIT(&mgr->evicte_list); - session_transition_init(); - mgr->now_ms = now_ms; - mgr->last_clean_expired_sess_ts = now_ms; - - return mgr; - -error: - session_manager_free(mgr); - return NULL; -} - -void session_manager_free(struct session_manager *mgr) -{ - struct session *sess; - if (mgr) - { - // free all evicted session - while ((sess = TAILQ_FIRST(&mgr->evicte_list))) - { - TAILQ_REMOVE(&mgr->evicte_list, sess, evicte_tqe); - session_manager_free_session(mgr, sess); - } - // free all udp session - while (mgr->udp_sess_table && (sess = session_table_find_lru(mgr->udp_sess_table))) - { - session_manager_free_session(mgr, sess); - } - // free all tcp session - while (mgr->tcp_sess_table && (sess = session_table_find_lru(mgr->tcp_sess_table))) - { - session_manager_free_session(mgr, sess); - } - if (mgr->cfg.evicted_session_bloom_filter.enable) - { - session_filter_free(mgr->evicte_sess_filter); - } - if (mgr->cfg.duplicated_packet_bloom_filter.enable) - { - packet_filter_free(mgr->dup_pkt_filter); - } - snowflake_free(mgr->sf); - session_timer_free(mgr->sess_timer); - session_table_free(mgr->udp_sess_table); - session_table_free(mgr->tcp_sess_table); - session_pool_free(mgr->sess_pool); - free(mgr); - mgr = NULL; - } -} - -void session_manager_record_duplicated_packet(struct session_manager *mgr, const struct packet *pkt) -{ - if (mgr->cfg.duplicated_packet_bloom_filter.enable) - { - packet_filter_add(mgr->dup_pkt_filter, pkt, mgr->now_ms); - } -} - -struct session *session_manager_new_session(struct session_manager *mgr, const struct packet *pkt, uint64_t now_ms) -{ - mgr->now_ms = now_ms; + sess_mgr_rt->now_ms = now_ms; struct tuple6 key; if (packet_get_innermost_tuple6(pkt, &key)) @@ -1048,51 +1040,51 @@ struct session *session_manager_new_session(struct session_manager *mgr, const s switch (key.ip_proto) { case IPPROTO_TCP: - if (tcp_overload_bypass(mgr, &key)) + if (session_manager_runtime_bypass_packet_on_tcp_table_limit(sess_mgr_rt, &key)) { return NULL; } - return session_manager_new_tcp_session(mgr, pkt, &key); + return session_manager_runtime_new_tcp_session(sess_mgr_rt, pkt, &key); case IPPROTO_UDP: - if (udp_overload_bypass(mgr, &key)) + if (session_manager_runtime_bypass_packet_on_session_evicted(sess_mgr_rt, &key)) { return NULL; } - if (evicted_session_bypass(mgr, &key)) + if (session_manager_runtime_bypass_packet_on_udp_table_limit(sess_mgr_rt, &key)) { return NULL; } - return session_manager_new_udp_session(mgr, pkt, &key); + return session_manager_runtime_new_udp_session(sess_mgr_rt, pkt, &key); default: return NULL; } } -void session_manager_free_session(struct session_manager *mgr, struct session *sess) +void session_manager_runtime_free_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess) { if (sess) { SESSION_LOG_DEBUG("session %lu closed (%s)", session_get_id(sess), closing_reason_to_str(session_get_closing_reason(sess))); - session_timer_del(mgr->sess_timer, sess); + session_timer_del(sess_mgr_rt->sess_timer, sess); switch (session_get_type(sess)) { case SESSION_TYPE_TCP: - tcp_clean(mgr, sess); - if (session_table_find_sessid(mgr->tcp_sess_table, session_get_id(sess), 0) == sess) + tcp_clean(sess_mgr_rt, sess); + if (session_table_find_sessid(sess_mgr_rt->tcp_sess_table, session_get_id(sess), 0) == sess) { - session_table_del(mgr->tcp_sess_table, sess); + session_table_del(sess_mgr_rt->tcp_sess_table, sess); } - SESS_MGR_STAT_DEC(&mgr->stat, session_get_current_state(sess), tcp); - mgr->stat.tcp_sess_used--; + SESS_MGR_STAT_DEC(&sess_mgr_rt->stat, session_get_current_state(sess), tcp); + sess_mgr_rt->stat.tcp_sess_used--; break; case SESSION_TYPE_UDP: - if (session_table_find_sessid(mgr->udp_sess_table, session_get_id(sess), 0) == sess) + if (session_table_find_sessid(sess_mgr_rt->udp_sess_table, session_get_id(sess), 0) == sess) { - session_table_del(mgr->udp_sess_table, sess); + session_table_del(sess_mgr_rt->udp_sess_table, sess); } - SESS_MGR_STAT_DEC(&mgr->stat, session_get_current_state(sess), udp); - mgr->stat.udp_sess_used--; + SESS_MGR_STAT_DEC(&sess_mgr_rt->stat, session_get_current_state(sess), udp); + sess_mgr_rt->stat.udp_sess_used--; break; default: assert(0); @@ -1110,12 +1102,12 @@ void session_manager_free_session(struct session_manager *mgr, struct session *s session_set_current_state(sess, SESSION_STATE_INIT); session_set_current_packet(sess, NULL); session_set_flow_type(sess, FLOW_TYPE_NONE); - session_pool_push(mgr->sess_pool, sess); + session_pool_push(sess_mgr_rt->sess_pool, sess); sess = NULL; } } -struct session *session_manager_lookup_session_by_packet(struct session_manager *mgr, const struct packet *pkt) +struct session *session_manager_runtime_lookup_session_by_packet(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt) { struct tuple6 key; if (packet_get_innermost_tuple6(pkt, &key)) @@ -1125,24 +1117,24 @@ struct session *session_manager_lookup_session_by_packet(struct session_manager switch (key.ip_proto) { case IPPROTO_UDP: - return session_table_find_tuple6(mgr->udp_sess_table, &key, 0); + return session_table_find_tuple6(sess_mgr_rt->udp_sess_table, &key, 0); case IPPROTO_TCP: - return session_manager_lookup_tcp_session(mgr, pkt, &key); + return session_manager_runtime_lookup_tcp_session(sess_mgr_rt, pkt, &key); default: return NULL; } } -struct session *session_manager_lookup_session_by_id(struct session_manager *mgr, uint64_t sess_id) +struct session *session_manager_runtime_lookup_session_by_id(struct session_manager_runtime *sess_mgr_rt, uint64_t sess_id) { struct session *sess = NULL; - sess = session_table_find_sessid(mgr->tcp_sess_table, sess_id, 1); + sess = session_table_find_sessid(sess_mgr_rt->tcp_sess_table, sess_id, 1); if (sess) { return sess; } - sess = session_table_find_sessid(mgr->udp_sess_table, sess_id, 1); + sess = session_table_find_sessid(sess_mgr_rt->udp_sess_table, sess_id, 1); if (sess) { return sess; @@ -1151,35 +1143,35 @@ struct session *session_manager_lookup_session_by_id(struct session_manager *mgr return NULL; } -int session_manager_update_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, uint64_t now_ms) +int session_manager_runtime_update_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess, const struct packet *pkt, uint64_t now_ms) { - mgr->now_ms = now_ms; + sess_mgr_rt->now_ms = now_ms; struct tuple6 key; if (packet_get_innermost_tuple6(pkt, &key)) { return -1; } - if (duplicated_packet_bypass(mgr, sess, pkt, &key)) + if (session_manager_runtime_bypass_duplicated_packet(sess_mgr_rt, sess, pkt, &key)) { return -1; } switch (session_get_type(sess)) { case SESSION_TYPE_TCP: - return session_manager_update_tcp_session(mgr, sess, pkt, &key); + return session_manager_runtime_update_tcp_session(sess_mgr_rt, sess, pkt, &key); case SESSION_TYPE_UDP: - return session_manager_update_udp_session(mgr, sess, pkt, &key); + return session_manager_runtime_update_udp_session(sess_mgr_rt, sess, pkt, &key); default: return -1; } } -struct session *session_manager_get_expired_session(struct session_manager *mgr, uint64_t now_ms) +struct session *session_manager_runtime_get_expired_session(struct session_manager_runtime *sess_mgr_rt, uint64_t now_ms) { - mgr->now_ms = now_ms; + sess_mgr_rt->now_ms = now_ms; - struct session *sess = session_timer_expire(mgr->sess_timer, now_ms); + struct session *sess = session_timer_expire(sess_mgr_rt->sess_timer, now_ms); if (sess) { enum session_state curr_state = session_get_current_state(sess); @@ -1190,10 +1182,10 @@ struct session *session_manager_get_expired_session(struct session_manager *mgr, switch (session_get_type(sess)) { case SESSION_TYPE_TCP: - SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, tcp); + SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, tcp); break; case SESSION_TYPE_UDP: - SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, udp); + SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, udp); break; default: assert(0); @@ -1215,10 +1207,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_timeout_ms.data); + session_timer_update(sess_mgr_rt->sess_timer, sess, now_ms + sess_mgr_rt->cfg.tcp_timeout_ms.data); break; case SESSION_TYPE_UDP: - session_timer_update(mgr->sess_timer, sess, now_ms + mgr->cfg.udp_timeout_ms.data); + session_timer_update(sess_mgr_rt->sess_timer, sess, now_ms + sess_mgr_rt->cfg.udp_timeout_ms.data); break; default: assert(0); @@ -1231,26 +1223,25 @@ struct session *session_manager_get_expired_session(struct session_manager *mgr, return NULL; } -struct session *session_manager_get_evicted_session(struct session_manager *mgr) +struct session *session_manager_runtime_get_evicted_session(struct session_manager_runtime *sess_mgr_rt) { - struct session *sess = TAILQ_FIRST(&mgr->evicte_list); + struct session *sess = TAILQ_FIRST(&sess_mgr_rt->evicte_list); if (sess) { - TAILQ_REMOVE(&mgr->evicte_list, sess, evicte_tqe); + TAILQ_REMOVE(&sess_mgr_rt->evicte_list, sess, evicte_tqe); } return sess; } -// array_size at least EVICTE_SESSION_BURST, suggest 2 * EVICTE_SESSION_BURST -uint64_t session_manager_clean_session(struct session_manager *mgr, uint64_t now_ms, struct session *cleaned_sess[], uint64_t array_size) +uint64_t session_manager_runtime_clean_session(struct session_manager_runtime *sess_mgr_rt, uint64_t now_ms, struct session *cleaned_sess[], uint64_t array_size) { - mgr->now_ms = now_ms; + sess_mgr_rt->now_ms = now_ms; struct session *sess = NULL; uint64_t cleaned_sess_num = 0; uint64_t expired_sess_num = 0; uint8_t expired_sess_canbe_clean = 0; - if (now_ms - mgr->last_clean_expired_sess_ts >= mgr->cfg.expire_period_ms) + if (now_ms - sess_mgr_rt->last_clean_expired_sess_ts >= sess_mgr_rt->cfg.expire_period_ms) { expired_sess_canbe_clean = 1; } @@ -1258,7 +1249,7 @@ uint64_t session_manager_clean_session(struct session_manager *mgr, uint64_t now for (uint64_t i = 0; i < array_size; i++) { // frist clean evicted session - sess = session_manager_get_evicted_session(mgr); + sess = session_manager_runtime_get_evicted_session(sess_mgr_rt); if (sess) { cleaned_sess[cleaned_sess_num++] = sess; @@ -1266,10 +1257,10 @@ 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.expire_batch_max) + if (expired_sess_canbe_clean && expired_sess_num < sess_mgr_rt->cfg.expire_batch_max) { - mgr->last_clean_expired_sess_ts = now_ms; - sess = session_manager_get_expired_session(mgr, now_ms); + sess_mgr_rt->last_clean_expired_sess_ts = now_ms; + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, now_ms); if (sess) { cleaned_sess[cleaned_sess_num++] = sess; @@ -1290,42 +1281,56 @@ uint64_t session_manager_clean_session(struct session_manager *mgr, uint64_t now return cleaned_sess_num; } -uint64_t session_manager_get_expire_interval(struct session_manager *mgr) +/****************************************************************************** + * stat -- get / print + ******************************************************************************/ + +struct session_manager_stat *session_manager_runtime_get_stat(struct session_manager_runtime *sess_mgr_rt) { - return session_timer_next_expire_interval(mgr->sess_timer); + return &sess_mgr_rt->stat; } -struct session_manager_stat *session_manager_stat(struct session_manager *mgr) +void session_manager_runtime_print_stat(struct session_manager_runtime *sess_mgr_rt) { - return &mgr->stat; + struct session_manager_stat *stat = &sess_mgr_rt->stat; + + // TCP session + SESSION_LOG_INFO("TCP session: history=%lu, used=%lu, opening=%lu, active=%lu, closing=%lu, discard=%lu, closed=%lu", + stat->history_tcp_sessions, stat->tcp_sess_used, stat->tcp_sess_opening, stat->tcp_sess_active, + stat->tcp_sess_closing, stat->tcp_sess_discard, stat->tcp_sess_closed); + // UDP session + SESSION_LOG_INFO("UDP session: history=%lu, used=%lu, opening=%lu, active=%lu, closing=%lu, discard=%lu, closed=%lu", + stat->history_udp_sessions, stat->udp_sess_used, stat->udp_sess_opening, stat->udp_sess_active, + stat->udp_sess_closing, stat->udp_sess_discard, stat->udp_sess_closed); + // evicted session + SESSION_LOG_INFO("evicted session: TCP=%lu, UDP=%lu", stat->tcp_sess_evicted, stat->udp_sess_evicted); + // Bypassed packet + SESSION_LOG_INFO("bypassed TCP packet: table_full=%lu, session_not_found=%lu, duplicated=%lu", + stat->tcp_pkts_bypass_table_full, stat->tcp_pkts_bypass_session_not_found, stat->tcp_pkts_bypass_duplicated); + SESSION_LOG_INFO("bypassed UDP packet: table_full=%lu, session_evicted=%lu, duplicated=%lu", + stat->udp_pkts_bypass_table_full, stat->udp_pkts_bypass_session_evicted, stat->udp_pkts_bypass_duplicated); + // TCP segment + SESSION_LOG_INFO("TCP segment: input=%lu, consumed=%lu, timeout=%lu, retransmited=%lu, overlapped=%lu, omitted_too_many=%lu, inorder=%lu, reordered=%lu, buffered=%lu, freed=%lu", + stat->tcp_segs_input, stat->tcp_segs_consumed, stat->tcp_segs_timeout, stat->tcp_segs_retransmited, + stat->tcp_segs_overlapped, stat->tcp_segs_omitted_too_many, stat->tcp_segs_inorder, stat->tcp_segs_reordered, + stat->tcp_segs_buffered, stat->tcp_segs_freed); } -void session_set_discard(struct session *sess) +/****************************************************************************** + * scan + ******************************************************************************/ + +static inline uint8_t ipv4_in_range(const struct in_addr *addr, const struct in_addr *start, const struct in_addr *end) { - struct session_manager *mgr = sess->mgr; - enum session_type type = session_get_type(sess); - enum session_state curr_state = session_get_current_state(sess); - enum session_state next_state = session_transition_run(curr_state, USER_CLOSE); - session_transition_log(sess, curr_state, next_state, USER_CLOSE); - session_set_current_state(sess, next_state); + return (memcmp(addr, start, sizeof(struct in_addr)) >= 0 && memcmp(addr, end, sizeof(struct in_addr)) <= 0); +} - switch (type) - { - case SESSION_TYPE_TCP: - 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_timeout_ms.discard_default); - SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, udp); - break; - default: - assert(0); - break; - } +static inline uint8_t ipv6_in_range(const struct in6_addr *addr, const struct in6_addr *start, const struct in6_addr *end) +{ + return (memcmp(addr, start, sizeof(struct in6_addr)) >= 0 && memcmp(addr, end, sizeof(struct in6_addr)) <= 0); } -uint64_t session_manager_scan(const struct session_manager *mgr, const struct session_scan_opts *opts, uint64_t mached_sess_ids[], uint64_t array_size) +uint64_t session_manager_runtime_scan(const struct session_manager_runtime *sess_mgr_rt, const struct session_scan_opts *opts, uint64_t mached_sess_ids[], uint64_t array_size) { uint64_t capacity = 0; uint64_t max_loop = 0; @@ -1333,7 +1338,7 @@ uint64_t session_manager_scan(const struct session_manager *mgr, const struct se const struct session *sess = NULL; const struct tuple6 *tuple = NULL; - if (mgr == NULL || opts == NULL || mached_sess_ids == NULL || array_size == 0) + if (sess_mgr_rt == NULL || opts == NULL || mached_sess_ids == NULL || array_size == 0) { return mached_sess_num; } @@ -1341,7 +1346,7 @@ uint64_t session_manager_scan(const struct session_manager *mgr, const struct se { return mached_sess_num; } - capacity = session_pool_capacity_size(mgr->sess_pool); + capacity = session_pool_capacity_size(sess_mgr_rt->sess_pool); if (opts->cursor >= capacity) { return mached_sess_num; @@ -1350,7 +1355,7 @@ uint64_t session_manager_scan(const struct session_manager *mgr, const struct se max_loop = MIN(capacity, opts->cursor + opts->count); for (uint64_t i = opts->cursor; i < max_loop; i++) { - sess = session_pool_get0(mgr->sess_pool, i); + sess = session_pool_get0(sess_mgr_rt->sess_pool, i); tuple = session_get_tuple6(sess); if (session_get_current_state(sess) == SESSION_STATE_INIT) { @@ -1426,3 +1431,32 @@ uint64_t session_manager_scan(const struct session_manager *mgr, const struct se SESSION_LOG_DEBUG("session scan: cursor=%lu, count=%lu, mached_sess_num=%lu", opts->cursor, opts->count, mached_sess_num); return mached_sess_num; } + +/****************************************************************************** + * other + ******************************************************************************/ + +void session_set_discard(struct session *sess) +{ + struct session_manager_runtime *sess_mgr_rt = sess->sess_mgr_rt; + enum session_type type = session_get_type(sess); + enum session_state curr_state = session_get_current_state(sess); + enum session_state next_state = session_transition_run(curr_state, USER_CLOSE); + session_transition_log(sess, curr_state, next_state, USER_CLOSE); + session_set_current_state(sess, next_state); + + switch (type) + { + case SESSION_TYPE_TCP: + session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + sess_mgr_rt->cfg.tcp_timeout_ms.discard_default); + SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, tcp); + break; + case SESSION_TYPE_UDP: + session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + sess_mgr_rt->cfg.udp_timeout_ms.discard_default); + SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, udp); + break; + default: + assert(0); + break; + } +}
\ No newline at end of file diff --git a/infra/session_manager/session_manager.h b/infra/session_manager/session_manager.h index 6bf843b..910c6a7 100644 --- a/infra/session_manager/session_manager.h +++ b/infra/session_manager/session_manager.h @@ -61,7 +61,7 @@ struct session_manager_config } tcp_reassembly; }; -struct __attribute__((aligned(64))) session_manager_stat +struct session_manager_stat { // TCP session uint64_t history_tcp_sessions; @@ -104,7 +104,7 @@ struct __attribute__((aligned(64))) session_manager_stat uint64_t tcp_segs_reordered; // sum uint64_t tcp_segs_buffered; // sum uint64_t tcp_segs_freed; // sum -}; +} __attribute__((aligned(64))); enum session_scan_flags { @@ -142,34 +142,35 @@ struct session_scan_opts uint64_t last_pkt_time_ms[2]; }; +// new/free/print config struct session_manager_config *session_manager_config_new(const char *toml_file); -void session_manager_config_free(struct session_manager_config *cfg); -void session_manager_config_print(struct session_manager_config *cfg); - -struct session_manager; -struct session_manager *session_manager_new(const struct session_manager_config *cfg, uint64_t now_ms); -void session_manager_free(struct session_manager *mgr); - -void session_manager_record_duplicated_packet(struct session_manager *mgr, const struct packet *pkt); - -struct session *session_manager_new_session(struct session_manager *mgr, const struct packet *pkt, uint64_t now_ms); -void session_manager_free_session(struct session_manager *mgr, struct session *sess); - -struct session *session_manager_lookup_session_by_packet(struct session_manager *mgr, const struct packet *pkt); -struct session *session_manager_lookup_session_by_id(struct session_manager *mgr, uint64_t sess_id); -int session_manager_update_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, uint64_t now_ms); - -// return session need free by session_manager_free_session() -struct session *session_manager_get_expired_session(struct session_manager *mgr, uint64_t now_ms); -struct session *session_manager_get_evicted_session(struct session_manager *mgr); -uint64_t session_manager_clean_session(struct session_manager *mgr, uint64_t now_ms, struct session *cleaned_sess[], uint64_t array_size); - -// return 0: have already timeout session -// return >0: next expire interval -uint64_t session_manager_get_expire_interval(struct session_manager *mgr); - -struct session_manager_stat *session_manager_stat(struct session_manager *mgr); -uint64_t session_manager_scan(const struct session_manager *mgr, const struct session_scan_opts *opts, uint64_t mached_sess_ids[], uint64_t array_size); +void session_manager_config_free(struct session_manager_config *sess_mgr_cfg); +void session_manager_config_print(struct session_manager_config *sess_mgr_cfg); + +// new/free runtime +struct session_manager_runtime; +struct session_manager_runtime *session_manager_runtime_new(const struct session_manager_config *sess_mgr_cfg, uint64_t now_ms); +void session_manager_runtime_free(struct session_manager_runtime *sess_mgr_rt); + +// new/free/lookup/update/clean session +struct session *session_manager_runtime_new_session(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt, uint64_t now_ms); +void session_manager_runtime_free_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess); +struct session *session_manager_runtime_lookup_session_by_packet(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt); +struct session *session_manager_runtime_lookup_session_by_id(struct session_manager_runtime *sess_mgr_rt, uint64_t sess_id); +int session_manager_runtime_update_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess, const struct packet *pkt, uint64_t now_ms); +struct session *session_manager_runtime_get_expired_session(struct session_manager_runtime *sess_mgr_rt, uint64_t now_ms); +struct session *session_manager_runtime_get_evicted_session(struct session_manager_runtime *sess_mgr_rt); +uint64_t session_manager_runtime_clean_session(struct session_manager_runtime *sess_mgr_rt, uint64_t now_ms, struct session *cleaned_sess[], uint64_t array_size); + +// stat +struct session_manager_stat *session_manager_runtime_get_stat(struct session_manager_runtime *sess_mgr_rt); +void session_manager_runtime_print_stat(struct session_manager_runtime *sess_mgr_rt); + +// scan +uint64_t session_manager_runtime_scan(const struct session_manager_runtime *sess_mgr_rt, const struct session_scan_opts *opts, uint64_t mached_sess_ids[], uint64_t array_size); + +// duplicated packet +void session_manager_runtime_record_duplicated_packet(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt); #ifdef __cplusplus } diff --git a/infra/session_manager/session_utils.c b/infra/session_manager/session_utils.c index ac6bb86..062eb53 100644 --- a/infra/session_manager/session_utils.c +++ b/infra/session_manager/session_utils.c @@ -206,7 +206,7 @@ struct tcp_segment *session_get_tcp_segment(struct session *sess) if (half->in_order.data != NULL && half->in_order.len > 0 && half->in_order_ref == 0) { - sess->mgr_stat->tcp_segs_consumed++; + sess->sess_mgr_stat->tcp_segs_consumed++; half->in_order_ref++; return &half->in_order; } @@ -219,8 +219,8 @@ struct tcp_segment *session_get_tcp_segment(struct session *sess) session_inc_stat(sess, type, STAT_TCP_PAYLOADS_REORDERED, seg->len); // TODO - sess->mgr_stat->tcp_segs_consumed++; - sess->mgr_stat->tcp_segs_reordered++; + sess->sess_mgr_stat->tcp_segs_consumed++; + sess->sess_mgr_stat->tcp_segs_reordered++; } return seg; } @@ -246,7 +246,7 @@ void session_free_tcp_segment(struct session *sess, struct tcp_segment *seg) { session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RELEASED, 1); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RELEASED, seg->len); - sess->mgr_stat->tcp_segs_freed++; + sess->sess_mgr_stat->tcp_segs_freed++; tcp_segment_free(seg); } diff --git a/infra/session_manager/test/default_config.h b/infra/session_manager/test/default_config.h index 607c7b7..729caed 100644 --- a/infra/session_manager/test/default_config.h +++ b/infra/session_manager/test/default_config.h @@ -9,7 +9,7 @@ extern "C" #include "session_manager.h" -static struct session_manager_config cfg = { +static struct session_manager_config sess_mgr_cfg = { .session_id_seed = 0xFFFFF, .tcp_session_max = 256, .udp_session_max = 256, diff --git a/infra/session_manager/test/gtest_case_tcp_fast_open.cpp b/infra/session_manager/test/gtest_case_tcp_fast_open.cpp index 50011ba..0f7e80c 100644 --- a/infra/session_manager/test/gtest_case_tcp_fast_open.cpp +++ b/infra/session_manager/test/gtest_case_tcp_fast_open.cpp @@ -263,11 +263,11 @@ TEST(CASE, TCP_FAST_OPEN) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S fast open packet\n"); @@ -276,9 +276,9 @@ TEST(CASE, TCP_FAST_OPEN) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_id(sess) != 0); @@ -347,32 +347,32 @@ TEST(CASE, TCP_FAST_OPEN) session_free_tcp_segment(sess, seg); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 1); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); // opening -> closing + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_free(mgr); + session_manager_runtime_free(sess_mgr_rt); } #endif diff --git a/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp b/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp index 6869565..8ae1a9b 100644 --- a/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp +++ b/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp @@ -19,11 +19,11 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP) { struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -32,14 +32,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); // C2S SYN dup Packet printf("\n=> Packet Parse: TCP C2S SYN dup packet\n"); @@ -48,14 +48,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == -1); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == -1); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1); - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 1); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1); // C2S SYN retransmission Packet printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n"); @@ -67,16 +67,16 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1); - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 1); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1); - session_manager_free(mgr); + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -85,11 +85,11 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP) { struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // S2C SYNACK Packet printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); @@ -98,14 +98,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); // S2C SYNACK dup Packet printf("\n=> Packet Parse: TCP S2C SYNACK dup packet\n"); @@ -114,14 +114,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == -1); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == -1); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1); - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 1); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1); // S2C SYNACK retransmission Packet printf("\n=> Packet Parse: TCP S2C SYNACK retransmission packet\n"); @@ -133,16 +133,16 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1); - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 1); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1); - session_manager_free(mgr); + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -151,12 +151,12 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP) { struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; char syn_retransmission[1500] = {0}; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -165,14 +165,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); // C2S SYN retransmission Packet printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n"); @@ -183,14 +183,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); // C2S SYN retransmission Packet printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n"); @@ -201,14 +201,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); // C2S SYN dup Packet printf("\n=> Packet Parse: TCP C2S SYN dup packet\n"); @@ -217,16 +217,16 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); - session_manager_free(mgr); + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -235,14 +235,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP) { struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; struct session_manager_config _cfg; - memcpy(&_cfg, &cfg, sizeof(struct session_manager_config)); + memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config)); _cfg.duplicated_packet_bloom_filter.enable = 0; - mgr = session_manager_new(&_cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -251,14 +251,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); // C2S SYN dup Packet printf("\n=> Packet Parse: TCP C2S SYN dup packet\n"); @@ -267,16 +267,16 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); - session_manager_free(mgr); + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -285,14 +285,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP) { struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; struct session_manager_config _cfg; - memcpy(&_cfg, &cfg, sizeof(struct session_manager_config)); + memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config)); _cfg.duplicated_packet_bloom_filter.enable = 0; - mgr = session_manager_new(&_cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // S2C SYNACK Packet printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); @@ -301,14 +301,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); // S2C SYNACK dup Packet printf("\n=> Packet Parse: TCP S2C SYNACK dup packet\n"); @@ -317,16 +317,16 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); - session_manager_free(mgr); + session_manager_runtime_free(sess_mgr_rt); } #endif diff --git a/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp b/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp index 36e815a..6518104 100644 --- a/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp +++ b/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp @@ -19,15 +19,15 @@ static void packet_set_ip_src_addr(struct packet *pkt, uint32_t addr) TEST(TCP_OVERLOAD, EVICT_OLD_SESS) { struct packet pkt; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; struct session_manager_config _cfg; - memcpy(&_cfg, &cfg, sizeof(struct session_manager_config)); + memcpy(&_cfg, &sess_mgr_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); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -39,21 +39,21 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS) 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)); + EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1)); } 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.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); - EXPECT_TRUE(stat->tcp_sess_closed == RX_BURST_MAX); // have evicted, have't free - EXPECT_TRUE(stat->tcp_sess_evicted == RX_BURST_MAX); - EXPECT_TRUE(stat->tcp_pkts_bypass_table_full == 0); - EXPECT_TRUE(stat->tcp_pkts_bypass_session_not_found == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _cfg.tcp_session_max); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == RX_BURST_MAX); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closed == RX_BURST_MAX); // have evicted, have't free + EXPECT_TRUE(sess_mgr_stat->tcp_sess_evicted == RX_BURST_MAX); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_table_full == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_session_not_found == 0); - session_manager_free(mgr); + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -61,16 +61,16 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS) TEST(TCP_OVERLOAD, EVICT_NEW_SESS) { struct packet pkt; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; struct session_manager_config _cfg; - memcpy(&_cfg, &cfg, sizeof(struct session_manager_config)); + memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config)); _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); + sess_mgr_rt = session_manager_runtime_new(&_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -82,40 +82,40 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS) 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)); + EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1)); } 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.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); - EXPECT_TRUE(stat->tcp_sess_evicted == 0); - EXPECT_TRUE(stat->tcp_pkts_bypass_table_full == 0); - EXPECT_TRUE(stat->tcp_pkts_bypass_session_not_found == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _cfg.tcp_session_max); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _cfg.tcp_session_max); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closed == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_evicted == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_table_full == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_session_not_found == 0); // table full, evict new session for (uint32_t i = 0; i < RX_BURST_MAX; 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); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &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.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); - EXPECT_TRUE(stat->tcp_sess_evicted == 0); - EXPECT_TRUE(stat->tcp_pkts_bypass_table_full == RX_BURST_MAX); - EXPECT_TRUE(stat->tcp_pkts_bypass_session_not_found == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _cfg.tcp_session_max); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _cfg.tcp_session_max); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closed == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_evicted == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_table_full == RX_BURST_MAX); + EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_session_not_found == 0); - session_manager_free(mgr); + session_manager_runtime_free(sess_mgr_rt); } #endif diff --git a/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp b/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp index 1595e8e..aefe600 100644 --- a/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp +++ b/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp @@ -20,15 +20,15 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS) { struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; struct session_manager_config _cfg; - memcpy(&_cfg, &cfg, sizeof(struct session_manager_config)); + memcpy(&_cfg, &sess_mgr_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); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S REQ Packet printf("\n=> Packet Parse: UDP C2S REQ packet\n"); @@ -40,27 +40,27 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS) 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)); + EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1)); } 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.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); - EXPECT_TRUE(stat->udp_sess_closed == RX_BURST_MAX); // have evicted, have't free - EXPECT_TRUE(stat->udp_sess_evicted == RX_BURST_MAX); - EXPECT_TRUE(stat->udp_pkts_bypass_table_full == 0); - EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _cfg.udp_session_max); + EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == RX_BURST_MAX); + EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == RX_BURST_MAX); // have evicted, have't free + EXPECT_TRUE(sess_mgr_stat->udp_sess_evicted == RX_BURST_MAX); + EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == 0); + EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == 0); // evicted session while (1) { - sess = session_manager_get_evicted_session(mgr); + sess = session_manager_runtime_get_evicted_session(sess_mgr_rt); if (sess) { - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); } else { @@ -71,38 +71,38 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS) for (uint32_t i = 0; i < RX_BURST_MAX; i++) { packet_set_ip_src_addr(&pkt, i); - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); - EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL); // hit evicted session, can't renew session + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1) == NULL); // hit evicted session, can't renew session } printf("=> Session Manager: after readd %d evicted sessions\n", RX_BURST_MAX); - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->udp_sess_used == RX_BURST_MAX); - EXPECT_TRUE(stat->udp_sess_opening == RX_BURST_MAX); - EXPECT_TRUE(stat->udp_sess_active == 0); - EXPECT_TRUE(stat->udp_sess_closing == 0); - EXPECT_TRUE(stat->udp_sess_closed == 0); - EXPECT_TRUE(stat->udp_sess_evicted == RX_BURST_MAX); - EXPECT_TRUE(stat->udp_pkts_bypass_table_full == 0); - EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->udp_sess_used == RX_BURST_MAX); + EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == RX_BURST_MAX); + EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_evicted == RX_BURST_MAX); + EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == 0); + EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX); // 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_bloom_filter.time_window_ms)); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &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); - EXPECT_TRUE(stat->udp_sess_used == RX_BURST_MAX + 1); - EXPECT_TRUE(stat->udp_sess_opening == RX_BURST_MAX); - EXPECT_TRUE(stat->udp_sess_active == 0); - EXPECT_TRUE(stat->udp_sess_closing == 0); - EXPECT_TRUE(stat->udp_sess_closed == 1); // have evicted, have't free - EXPECT_TRUE(stat->udp_sess_evicted == RX_BURST_MAX + 1); - EXPECT_TRUE(stat->udp_pkts_bypass_table_full == 0); - EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->udp_sess_used == RX_BURST_MAX + 1); + EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == RX_BURST_MAX); + EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == 1); // have evicted, have't free + EXPECT_TRUE(sess_mgr_stat->udp_sess_evicted == RX_BURST_MAX + 1); + EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == 0); + EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -110,16 +110,16 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS) TEST(UDP_OVERLOAD, EVICT_NEW_SESS) { struct packet pkt; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; struct session_manager_config _cfg; - memcpy(&_cfg, &cfg, sizeof(struct session_manager_config)); + memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config)); _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); + sess_mgr_rt = session_manager_runtime_new(&_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S REQ Packet printf("\n=> Packet Parse: UDP C2S REQ packet\n"); @@ -131,43 +131,43 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS) 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)); + EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1)); } 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.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); - EXPECT_TRUE(stat->udp_sess_evicted == 0); - EXPECT_TRUE(stat->udp_pkts_bypass_table_full == 0); - EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _cfg.udp_session_max); + EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _cfg.udp_session_max); + EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_evicted == 0); + EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == 0); + EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == 0); // evicted session - EXPECT_TRUE(session_manager_get_evicted_session(mgr) == NULL); + EXPECT_TRUE(session_manager_runtime_get_evicted_session(sess_mgr_rt) == NULL); // table full, evict new session for (uint32_t i = 0; i < RX_BURST_MAX; 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); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &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.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); - EXPECT_TRUE(stat->udp_sess_evicted == 0); - EXPECT_TRUE(stat->udp_pkts_bypass_table_full == RX_BURST_MAX); - EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _cfg.udp_session_max); + EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _cfg.udp_session_max); + EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_evicted == 0); + EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == RX_BURST_MAX); + EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif diff --git a/infra/session_manager/test/gtest_sess_mgr_scan.cpp b/infra/session_manager/test/gtest_sess_mgr_scan.cpp index f784349..6b9530b 100644 --- a/infra/session_manager/test/gtest_sess_mgr_scan.cpp +++ b/infra/session_manager/test/gtest_sess_mgr_scan.cpp @@ -13,13 +13,13 @@ static inline void packet_overwrite_src_addr(struct packet *pkt, struct in_addr hdr->ip_src = addr; } -static inline void mached_session_print(const char *title, struct session_manager *mgr, uint64_t mached_sess_ids[], uint64_t mached_sess_num) +static inline void mached_session_print(const char *title, struct session_manager_runtime *sess_mgr_rt, uint64_t mached_sess_ids[], uint64_t mached_sess_num) { struct session *sess = NULL; printf("%-*s mached_sess_num: %lu\n", 40, title, mached_sess_num); for (uint64_t i = 0; i < mached_sess_num; i++) { - sess = session_manager_lookup_session_by_id(mgr, mached_sess_ids[i]); + sess = session_manager_runtime_lookup_session_by_id(sess_mgr_rt, mached_sess_ids[i]); printf("session id: %lu, addr: %s, type: %s, state: %s, start: %lu, last: %lu\n", mached_sess_ids[i], session_get0_readable_addr(sess), session_type_to_str(session_get_type(sess)), @@ -37,7 +37,7 @@ TEST(SESS_MGR_SCAN, OPTS) uint64_t mached_sess_ids[1460]; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; struct in_addr v4_src_addr1 = {}; struct in_addr v4_src_addr2 = {}; @@ -85,16 +85,16 @@ TEST(SESS_MGR_SCAN, OPTS) inet_pton(AF_INET6, "cafe::0000", &v6_dst_subnet_beg); inet_pton(AF_INET6, "cafe::ffff", &v6_dst_subnet_end); - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // new session memset(&pkt, 0, sizeof(pkt)); memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn)); packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn)); packet_overwrite_src_addr(&pkt, v4_src_addr1); - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); - sess = session_manager_new_session(mgr, &pkt, 1); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // new session @@ -102,8 +102,8 @@ TEST(SESS_MGR_SCAN, OPTS) memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn)); packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn)); packet_overwrite_src_addr(&pkt, v4_src_addr2); - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); - sess = session_manager_new_session(mgr, &pkt, 2); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 2); EXPECT_TRUE(sess); // new session @@ -111,15 +111,15 @@ TEST(SESS_MGR_SCAN, OPTS) memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn)); packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn)); packet_overwrite_src_addr(&pkt, v4_src_addr3); - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); - sess = session_manager_new_session(mgr, &pkt, 3); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 3); EXPECT_TRUE(sess); // new session memset(&pkt, 0, sizeof(pkt)); packet_parse(&pkt, (const char *)ipv6_in_ipv6_udp, sizeof(ipv6_in_ipv6_udp)); - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); - sess = session_manager_new_session(mgr, &pkt, 4); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 4); EXPECT_TRUE(sess); struct session_scan_opts scan = {}; @@ -134,42 +134,42 @@ TEST(SESS_MGR_SCAN, OPTS) scan.flags = SESSION_SCAN_TYPE; scan.type = SESSION_TYPE_TCP; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 3); - mached_session_print("SESSION_SCAN_TYPE: (TCP)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_TYPE: (TCP)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.type = SESSION_TYPE_UDP; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 1); - mached_session_print("SESSION_SCAN_TYPE: (UDP)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_TYPE: (UDP)", sess_mgr_rt, mached_sess_ids, mached_sess_num); // SESSION_SCAN_STATE scan.flags = SESSION_SCAN_STATE; scan.state = SESSION_STATE_OPENING; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 4); - mached_session_print("SESSION_SCAN_STATE: (OPENING)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_STATE: (OPENING)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.state = SESSION_STATE_ACTIVE; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_STATE: (ACTIVE)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_STATE: (ACTIVE)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.state = SESSION_STATE_CLOSING; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_STATE: (CLOSING)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_STATE: (CLOSING)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.state = SESSION_STATE_DISCARD; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_STATE: (DISCARD)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_STATE: (DISCARD)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.state = SESSION_STATE_CLOSED; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_STATE: (CLOSED)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_STATE: (CLOSED)", sess_mgr_rt, mached_sess_ids, mached_sess_num); // SESSION_SCAN_SIP scan.flags = SESSION_SCAN_SIP; @@ -177,44 +177,44 @@ TEST(SESS_MGR_SCAN, OPTS) scan.addr_family = AF_INET; scan.src_addr[0].v4 = v4_src_addr1; scan.src_addr[1].v4 = v4_src_addr1; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 1); - mached_session_print("SESSION_SCAN_SIP: (IPv4)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_SIP: (IPv4)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.addr_family = AF_INET; scan.src_addr[0].v4 = v4_src_subnet_beg; scan.src_addr[1].v4 = v4_src_subnet_end; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 3); - mached_session_print("SESSION_SCAN_SIP: (IPv4 SUBNET)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_SIP: (IPv4 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.addr_family = AF_INET; scan.src_addr[0].v4 = v4_min_addr; scan.src_addr[1].v4 = v4_max_addr; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 3); - mached_session_print("SESSION_SCAN_SIP: (IPv4 MIN MAX)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_SIP: (IPv4 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.addr_family = AF_INET6; memcpy(&scan.src_addr[0].v6, &v6_src_addr, sizeof(v6_src_addr)); memcpy(&scan.src_addr[1].v6, &v6_src_addr, sizeof(v6_src_addr)); - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 1); - mached_session_print("SESSION_SCAN_SIP: (IPv6)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_SIP: (IPv6)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.addr_family = AF_INET6; memcpy(&scan.src_addr[0].v6, &v6_src_subnet_beg, sizeof(v6_src_subnet_beg)); memcpy(&scan.src_addr[1].v6, &v6_src_subnet_end, sizeof(v6_src_subnet_end)); - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 1); - mached_session_print("SESSION_SCAN_SIP: (IPv6 SUBNET)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_SIP: (IPv6 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.addr_family = AF_INET6; memcpy(&scan.src_addr[0].v6, &v6_min_addr, sizeof(v6_min_addr)); memcpy(&scan.src_addr[1].v6, &v6_max_addr, sizeof(v6_max_addr)); - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 1); - mached_session_print("SESSION_SCAN_SIP: (IPv6 MIN MAX)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_SIP: (IPv6 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num); // SESSION_SCAN_DIP scan.flags = SESSION_SCAN_DIP; @@ -222,126 +222,126 @@ TEST(SESS_MGR_SCAN, OPTS) scan.addr_family = AF_INET; scan.dst_addr[0].v4 = v4_dst_addr; scan.dst_addr[1].v4 = v4_dst_addr; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 3); - mached_session_print("SESSION_SCAN_DIP: (IPv4)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_DIP: (IPv4)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.addr_family = AF_INET; scan.dst_addr[0].v4 = v4_dst_subnet_beg; scan.dst_addr[1].v4 = v4_dst_subnet_end; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 3); - mached_session_print("SESSION_SCAN_DIP: (IPv4 SUBNET)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_DIP: (IPv4 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.addr_family = AF_INET; scan.dst_addr[0].v4 = v4_min_addr; scan.dst_addr[1].v4 = v4_max_addr; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 3); - mached_session_print("SESSION_SCAN_DIP: (IPv4 MIN MAX)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_DIP: (IPv4 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.addr_family = AF_INET6; memcpy(&scan.dst_addr[0].v6, &v6_dst_addr, sizeof(v6_dst_addr)); memcpy(&scan.dst_addr[1].v6, &v6_dst_addr, sizeof(v6_dst_addr)); - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 1); - mached_session_print("SESSION_SCAN_DIP: (IPv6)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_DIP: (IPv6)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.addr_family = AF_INET6; memcpy(&scan.dst_addr[0].v6, &v6_dst_subnet_beg, sizeof(v6_dst_subnet_beg)); memcpy(&scan.dst_addr[1].v6, &v6_dst_subnet_end, sizeof(v6_dst_subnet_end)); - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 1); - mached_session_print("SESSION_SCAN_DIP: (IPv6 SUBNET)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_DIP: (IPv6 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.addr_family = AF_INET6; memcpy(&scan.dst_addr[0].v6, &v6_min_addr, sizeof(v6_min_addr)); memcpy(&scan.dst_addr[1].v6, &v6_max_addr, sizeof(v6_max_addr)); - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 1); - mached_session_print("SESSION_SCAN_DIP: (IPv6 MIN MAX)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_DIP: (IPv6 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num); // SESSION_SCAN_SPORT scan.flags = SESSION_SCAN_SPORT; scan.src_port = htons(60111); - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 3); - mached_session_print("SESSION_SCAN_SPORT: (HIT)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_SPORT: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.src_port = htons(60110); - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_SPORT: (MISS)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_SPORT: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num); // SESSION_SCAN_DPORT scan.flags = SESSION_SCAN_DPORT; scan.dst_port = htons(80); - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 3); - mached_session_print("SESSION_SCAN_DPORT: (HIT)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_DPORT: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.dst_port = htons(81); - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_DPORT: (MISS)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_DPORT: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num); // SESSION_SCAN_CREATE_TIME scan.flags = SESSION_SCAN_CREATE_TIME; scan.create_time_ms[0] = 0; scan.create_time_ms[1] = UINT64_MAX; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 4); - mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.create_time_ms[0] = 1; scan.create_time_ms[1] = 2; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 2); - mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.create_time_ms[0] = 0; scan.create_time_ms[1] = 0; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.create_time_ms[0] = UINT64_MAX; scan.create_time_ms[1] = UINT64_MAX; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num); // SESSION_SCAN_LAST_PKT_TIME scan.flags = SESSION_SCAN_LAST_PKT_TIME; scan.last_pkt_time_ms[0] = 0; scan.last_pkt_time_ms[1] = UINT64_MAX; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 4); - mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.last_pkt_time_ms[0] = 1; scan.last_pkt_time_ms[1] = 2; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 2); - mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.last_pkt_time_ms[0] = 0; scan.last_pkt_time_ms[1] = 0; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num); scan.last_pkt_time_ms[0] = UINT64_MAX; scan.last_pkt_time_ms[1] = UINT64_MAX; - mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", mgr, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num); - session_manager_free(mgr); + session_manager_runtime_free(sess_mgr_rt); } #endif diff --git a/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp b/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp index abbe321..88eb20f 100644 --- a/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp +++ b/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp @@ -26,10 +26,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER) struct tcp_segment *seg; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -38,9 +38,9 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); seg = session_get_tcp_segment(sess); @@ -53,10 +53,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg == NULL); @@ -68,10 +68,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg == NULL); @@ -83,10 +83,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 4) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg == NULL); @@ -98,10 +98,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 5) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 5) == 0); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg == NULL); @@ -113,10 +113,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 6) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 6) == 0); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg == NULL); @@ -128,10 +128,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 7) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 7) == 0); /* * 11111111111111111111111111111111111111111111111111111111111111 @@ -198,16 +198,16 @@ 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_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(session_manager_runtime_get_expired_session(sess_mgr_rt, 7 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); // active -> closing + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 7 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); - session_manager_free(mgr); + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -217,10 +217,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND) struct tcp_segment *seg; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -229,9 +229,9 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); seg = session_get_tcp_segment(sess); @@ -244,10 +244,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg == NULL); @@ -259,10 +259,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg != NULL); @@ -278,10 +278,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 4) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg != NULL); @@ -291,16 +291,16 @@ 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_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(session_manager_runtime_get_expired_session(sess_mgr_rt, 4 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); // active -> closing + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 4 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); - session_manager_free(mgr); + session_manager_runtime_free(sess_mgr_rt); } #endif diff --git a/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp b/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp index 0c4b7aa..d45eb2b 100644 --- a/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp +++ b/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp @@ -8,7 +8,7 @@ #include "default_config.h" #include "test_packets.h" -static void build_active_tcp_session(struct session_manager *mgr, struct session *sess) +static void build_active_tcp_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess) { struct packet pkt; @@ -19,9 +19,9 @@ static void build_active_tcp_session(struct session_manager *mgr, struct session printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // C2S DATA Packet @@ -31,10 +31,10 @@ static void build_active_tcp_session(struct session_manager *mgr, struct session printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); } /****************************************************************************** @@ -47,14 +47,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet & C2S DATA Packet - build_active_tcp_session(mgr, sess); + build_active_tcp_session(sess_mgr_rt, sess); // C2S FIN Packet printf("\n=> Packet Parse: TCP C2S FIN packet\n"); @@ -63,10 +63,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); // S2C FIN Packet printf("\n=> Packet Parse: TCP S2C FIN packet\n"); @@ -75,10 +75,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -100,31 +100,31 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 1); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.time_wait); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -138,14 +138,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet & C2S DATA Packet - build_active_tcp_session(mgr, sess); + build_active_tcp_session(sess_mgr_rt, sess); // C2S RST Packet printf("\n=> Packet Parse: TCP C2S RST packet\n"); @@ -160,10 +160,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -185,31 +185,31 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 1); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.unverified_rst); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -223,14 +223,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet & C2S DATA Packet - build_active_tcp_session(mgr, sess); + build_active_tcp_session(sess_mgr_rt, sess); // S2C RST Packet printf("\n=> Packet Parse: TCP S2C RST packet\n"); @@ -245,10 +245,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -270,31 +270,31 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 1); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.unverified_rst); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -306,42 +306,42 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST) TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT) { struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet & C2S DATA Packet - build_active_tcp_session(mgr, sess); + build_active_tcp_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 1); - EXPECT_TRUE(stat->tcp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -355,14 +355,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet & C2S DATA Packet - build_active_tcp_session(mgr, sess); + build_active_tcp_session(sess_mgr_rt, sess); // C2S FIN Packet printf("\n=> Packet Parse: TCP C2S FIN packet\n"); @@ -371,10 +371,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -396,31 +396,31 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 1); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.half_closed); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -434,14 +434,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet & C2S DATA Packet - build_active_tcp_session(mgr, sess); + build_active_tcp_session(sess_mgr_rt, sess); // S2C FIN Packet printf("\n=> Packet Parse: TCP S2C FIN packet\n"); @@ -450,10 +450,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -475,31 +475,31 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 1); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.half_closed); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif diff --git a/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp b/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp index a466a34..92002b5 100644 --- a/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp +++ b/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp @@ -18,11 +18,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -31,9 +31,9 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_id(sess) != 0); @@ -56,32 +56,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 1); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); // opening -> closing + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -95,11 +95,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // S2C SYNACK Packet printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); @@ -108,9 +108,9 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_id(sess) != 0); @@ -133,32 +133,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 1); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -172,11 +172,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -185,9 +185,9 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // S2C SYNACK Packet @@ -197,10 +197,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -222,32 +222,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 1); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -261,11 +261,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -274,9 +274,9 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // S2C SYNACK Packet @@ -286,10 +286,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); // C2S ACK Packet printf("\n=> Packet Parse: TCP C2S ACK packet\n"); @@ -298,10 +298,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -323,32 +323,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 1); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -364,11 +364,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -377,9 +377,9 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // C2S SYN Packet retransmission @@ -394,10 +394,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -419,32 +419,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 1); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -460,11 +460,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // S2C SYNACK Packet printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); @@ -473,9 +473,9 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // SYNACK Packet retransmission @@ -491,10 +491,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -516,32 +516,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 1); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -555,11 +555,11 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -568,9 +568,9 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // C2S ACK Packet @@ -580,10 +580,10 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -605,32 +605,32 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 1); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -644,11 +644,11 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // S2C SYNACK Packet printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); @@ -657,9 +657,9 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // S2C ACK Packet @@ -669,10 +669,10 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -694,32 +694,32 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 1); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif diff --git a/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp b/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp index b5cbd9a..4678fd8 100644 --- a/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp +++ b/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp @@ -14,11 +14,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) char buffer[1024]; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -27,9 +27,9 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_id(sess) != 0); @@ -58,10 +58,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -89,10 +89,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -120,10 +120,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 4) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -151,10 +151,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 5) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 5) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -182,10 +182,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 6) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 6) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -213,10 +213,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 7) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 7) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -244,10 +244,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 8) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 8) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -275,10 +275,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 9) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 9) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -306,10 +306,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 10) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 10) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -337,10 +337,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 11) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 11) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -362,31 +362,31 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 1); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_get_expired_session(mgr, 11 + cfg.tcp_timeout_ms.time_wait); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 11 + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif diff --git a/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp b/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp index 6554ff4..a1e5fba 100644 --- a/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp +++ b/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp @@ -18,11 +18,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -31,9 +31,9 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // C2S DATA Packet @@ -43,10 +43,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -68,32 +68,32 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 1); - EXPECT_TRUE(stat->tcp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -107,11 +107,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // S2C SYNACK Packet printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); @@ -120,9 +120,9 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // S2C DATA Packet @@ -132,10 +132,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -157,32 +157,32 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 1); - EXPECT_TRUE(stat->tcp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif diff --git a/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp b/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp index 41c228a..06f4f16 100644 --- a/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp +++ b/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp @@ -18,11 +18,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -31,9 +31,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // C2S FIN Packet @@ -43,10 +43,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); // S2C FIN Packet printf("\n=> Packet Parse: TCP S2C FIN packet\n"); @@ -55,10 +55,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -80,31 +80,31 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 1); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.time_wait); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -118,11 +118,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -131,9 +131,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // C2S RST Packet @@ -149,10 +149,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -174,31 +174,31 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 1); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.unverified_rst); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -212,11 +212,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -225,9 +225,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // S2C RST Packet @@ -243,10 +243,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -268,31 +268,31 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 1); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.unverified_rst); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -305,11 +305,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT) { struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -318,38 +318,38 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 1); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -363,11 +363,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -376,9 +376,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // S2C SYNACK Packet @@ -388,10 +388,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -413,32 +413,32 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 1); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -452,11 +452,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -465,9 +465,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // S2C SYNACK Packet @@ -477,10 +477,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); // C2S ACK Packet printf("\n=> Packet Parse: TCP C2S ACK packet\n"); @@ -489,10 +489,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -514,32 +514,32 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 1); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -553,11 +553,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -566,9 +566,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // C2S FIN Packet @@ -578,10 +578,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -603,31 +603,31 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 1); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.half_closed); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -641,11 +641,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -654,9 +654,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // S2C FIN Packet @@ -666,10 +666,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -691,31 +691,31 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 1); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 1); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.half_closed); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->tcp_sess_used == 0); - EXPECT_TRUE(stat->tcp_sess_opening == 0); - EXPECT_TRUE(stat->tcp_sess_active == 0); - EXPECT_TRUE(stat->tcp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif diff --git a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp index 6078818..739f04d 100644 --- a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp +++ b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp @@ -14,11 +14,11 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S REQ Packet printf("\n=> Packet Parse: UDP C2S REQ packet\n"); @@ -27,9 +27,9 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_id(sess) != 0); @@ -57,10 +57,10 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -82,32 +82,32 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->udp_sess_used == 1); - EXPECT_TRUE(stat->udp_sess_opening == 0); - EXPECT_TRUE(stat->udp_sess_active == 1); - EXPECT_TRUE(stat->udp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 1); + EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // active -> closing + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->udp_sess_used == 0); - EXPECT_TRUE(stat->udp_sess_opening == 0); - EXPECT_TRUE(stat->udp_sess_active == 0); - EXPECT_TRUE(stat->udp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); - session_manager_free(mgr); + session_manager_runtime_free(sess_mgr_rt); } #endif diff --git a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp index bd26842..48f6f6a 100644 --- a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp +++ b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp @@ -19,11 +19,11 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S REQ Packet printf("\n=> Packet Parse: UDP C2S REQ packet\n"); @@ -32,9 +32,9 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_id(sess) != 0); @@ -57,32 +57,32 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->udp_sess_used == 1); - EXPECT_TRUE(stat->udp_sess_opening == 1); - EXPECT_TRUE(stat->udp_sess_active == 0); - EXPECT_TRUE(stat->udp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 1); + EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // opening -> closing + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->udp_sess_used == 0); - EXPECT_TRUE(stat->udp_sess_opening == 0); - EXPECT_TRUE(stat->udp_sess_active == 0); - EXPECT_TRUE(stat->udp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -97,11 +97,11 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; - struct session_manager_stat *stat = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_stat *sess_mgr_stat = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // S2C RESP Packet printf("\n=> Packet Parse: UDP S2C RESP packet\n"); @@ -110,9 +110,9 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_id(sess) != 0); @@ -135,16 +135,16 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C) session_print(sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->udp_sess_used == 1); - EXPECT_TRUE(stat->udp_sess_opening == 1); - EXPECT_TRUE(stat->udp_sess_active == 0); - EXPECT_TRUE(stat->udp_sess_closing == 0); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1); + EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 1); + EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // opening -> closing + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); @@ -152,17 +152,17 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C) session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); // check stat - stat = session_manager_stat(mgr); - EXPECT_TRUE(stat); - EXPECT_TRUE(stat->udp_sess_used == 0); - EXPECT_TRUE(stat->udp_sess_opening == 0); - EXPECT_TRUE(stat->udp_sess_active == 0); - EXPECT_TRUE(stat->udp_sess_closing == 0); - - session_manager_free(mgr); + sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + EXPECT_TRUE(sess_mgr_stat); + EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0); + EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); + + session_manager_runtime_free(sess_mgr_rt); } #endif diff --git a/infra/session_manager/test/gtest_timeout_tcp_data.cpp b/infra/session_manager/test/gtest_timeout_tcp_data.cpp index 0a47768..0cfcc57 100644 --- a/infra/session_manager/test/gtest_timeout_tcp_data.cpp +++ b/infra/session_manager/test/gtest_timeout_tcp_data.cpp @@ -12,10 +12,10 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA) { struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -24,9 +24,9 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // C2S DATA Packet @@ -36,22 +36,22 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); - session_manager_free(mgr); + session_manager_runtime_free(sess_mgr_rt); } #endif diff --git a/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp b/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp index ae2a810..d837a8a 100644 --- a/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp +++ b/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp @@ -12,10 +12,10 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE) { struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // S2C SYNACK Packet printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); @@ -24,22 +24,22 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL); + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); - session_manager_free(mgr); + session_manager_runtime_free(sess_mgr_rt); } #endif diff --git a/infra/session_manager/test/gtest_timeout_tcp_init.cpp b/infra/session_manager/test/gtest_timeout_tcp_init.cpp index 20bb5fa..b3ca04a 100644 --- a/infra/session_manager/test/gtest_timeout_tcp_init.cpp +++ b/infra/session_manager/test/gtest_timeout_tcp_init.cpp @@ -12,10 +12,10 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT) { struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -24,22 +24,22 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); // opening -> closing + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); - session_manager_free(mgr); + session_manager_runtime_free(sess_mgr_rt); } #endif diff --git a/infra/session_manager/test/gtest_timeout_udp_data.cpp b/infra/session_manager/test/gtest_timeout_udp_data.cpp index 6d9d69e..d5663fe 100644 --- a/infra/session_manager/test/gtest_timeout_udp_data.cpp +++ b/infra/session_manager/test/gtest_timeout_udp_data.cpp @@ -12,10 +12,10 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1) { struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S REQ Packet printf("\n=> Packet Parse: UDP C2S REQ packet\n"); @@ -24,22 +24,22 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // opening -> closing + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); - session_manager_free(mgr); + session_manager_runtime_free(sess_mgr_rt); } #endif @@ -48,10 +48,10 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2) { struct packet pkt; struct session *sess = NULL; - struct session_manager *mgr = NULL; + struct session_manager_runtime *sess_mgr_rt = NULL; - mgr = session_manager_new(&cfg, 1); - EXPECT_TRUE(mgr != NULL); + sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rt != NULL); // C2S REQ Packet printf("\n=> Packet Parse: UDP C2S REQ packet\n"); @@ -60,9 +60,9 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); + EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); // new session - sess = session_manager_new_session(mgr, &pkt, 1); + sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); EXPECT_TRUE(sess); // S2C RESP Packet @@ -72,22 +72,22 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_lookup_session_by_packet(mgr, &pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); EXPECT_TRUE(sess); // update session - EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); // expire session - 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(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // active -> closing + sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_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); session_print(sess); // free session - session_manager_free_session(mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); - session_manager_free(mgr); + session_manager_runtime_free(sess_mgr_rt); } #endif diff --git a/infra/stellar_core.c b/infra/stellar_core.c index f2563a6..b3e0471 100644 --- a/infra/stellar_core.c +++ b/infra/stellar_core.c @@ -42,7 +42,7 @@ struct stellar_thread uint16_t idx; uint64_t is_runing; struct ip_reassembly *ip_reass; - struct session_manager *sess_mgr; + struct session_manager_runtime *sess_mgr_rt; struct stellar *st; }; @@ -75,8 +75,6 @@ struct stellar static __thread uint16_t __current_thread_idx = UINT16_MAX; -uint64_t stellar_generate_session_id(uint64_t now_sec); - /****************************************************************************** * Stellar Thread Main Loop ******************************************************************************/ @@ -103,16 +101,16 @@ static void update_stat(struct session *sess, struct packet *pkt) } } -static inline void clean_session(struct session_manager *sess_mgr, uint64_t now_ms) +static inline void clean_session(struct session_manager_runtime *sess_mgr_rt, uint64_t now_ms) { struct session *sess = NULL; struct session *cleaned_sess[RX_BURST_MAX * 16]; - uint64_t nr_sess_cleaned = session_manager_clean_session(sess_mgr, now_ms, cleaned_sess, sizeof(cleaned_sess) / sizeof(cleaned_sess[0])); + uint64_t nr_sess_cleaned = session_manager_runtime_clean_session(sess_mgr_rt, now_ms, cleaned_sess, sizeof(cleaned_sess) / sizeof(cleaned_sess[0])); for (uint64_t j = 0; j < nr_sess_cleaned; j++) { sess = cleaned_sess[j]; // session_exdata_runtime_free(session_get_user_data(sess)); - session_manager_free_session(sess_mgr, sess); + session_manager_runtime_free_session(sess_mgr_rt, sess); } } @@ -127,8 +125,8 @@ static void *worker_thread(void *arg) struct session *sess = NULL; struct stellar_thread *thread = (struct stellar_thread *)arg; struct ip_reassembly *ip_reass = thread->ip_reass; - struct session_manager *sess_mgr = thread->sess_mgr; - struct session_manager_stat *sess_stat = session_manager_stat(sess_mgr); + struct session_manager_runtime *sess_mgr_rt = thread->sess_mgr_rt; + struct session_manager_stat *sess_stat = session_manager_runtime_get_stat(sess_mgr_rt); struct stellar *st = thread->st; struct stellar_runtime *runtime = &st->runtime; struct packet_io *packet_io = runtime->packet_io; @@ -140,7 +138,7 @@ static void *worker_thread(void *arg) struct thread_stat thr_stat = { .pkt_io = packet_io_stat(packet_io, thread->idx), .ip_reass = ip_reassembly_stat(ip_reass), - .sess_mgr = session_manager_stat(sess_mgr), + .sess_mgr = session_manager_runtime_get_stat(sess_mgr_rt), }; uint16_t thr_idx = thread->idx; @@ -189,6 +187,7 @@ static void *worker_thread(void *arg) defraged_pkt = NULL; pkt = &packets[i]; + // plugin_manager_on_packet_input(plug_mgr, pkt); if (packet_is_fragment(pkt)) { defraged_pkt = ip_reassembly_packet(ip_reass, pkt, now_ms); @@ -199,13 +198,14 @@ static void *worker_thread(void *arg) else { pkt = defraged_pkt; + // plugin_manager_on_packet_input(plug_mgr, defraged_pkt); } } - sess = session_manager_lookup_session_by_packet(sess_mgr, pkt); + sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, pkt); if (sess == NULL) { - sess = session_manager_new_session(sess_mgr, pkt, now_ms); + sess = session_manager_runtime_new_session(sess_mgr_rt, pkt, now_ms); if (sess == NULL) { goto fast_path; @@ -215,7 +215,7 @@ static void *worker_thread(void *arg) } else { - if (session_manager_update_session(sess_mgr, sess, pkt, now_ms) == -1) + if (session_manager_runtime_update_session(sess_mgr_rt, sess, pkt, now_ms) == -1) { goto fast_path; } @@ -224,9 +224,12 @@ static void *worker_thread(void *arg) fast_path: if (pkt == defraged_pkt) { + // plugin_manager_on_packet_output(plug_mgr, defraged_pkt); + // plugin_manager_on_packet_output(plug_mgr, &packets[i]); } else { + // plugin_manager_on_packet_output(plug_mgr, pkt); } if (sess) @@ -271,8 +274,9 @@ static void *worker_thread(void *arg) } idle_tasks: - clean_session(sess_mgr, now_ms); + clean_session(sess_mgr_rt, now_ms); ip_reassembly_expire(ip_reass, now_ms); + // plugin_manager_on_polling(plug_mgr); stellar_stat_merge(runtime->stat, &thr_stat, thr_idx, now_ms); if (nr_pkt_received == 0) @@ -285,7 +289,7 @@ static void *worker_thread(void *arg) while (sess_stat->tcp_sess_used > 0 || sess_stat->udp_sess_used > 0) { now_ms = clock_get_real_time_ms(); - clean_session(sess_mgr, now_ms); + clean_session(sess_mgr_rt, now_ms); usleep(1000); // 1ms } @@ -318,8 +322,8 @@ static int stellar_thread_init(struct stellar *st) thread->st = st; config->sess_mgr_cfg->session_id_seed = config->instance_id << 8 | i; - thread->sess_mgr = session_manager_new(config->sess_mgr_cfg, now_ms); - if (thread->sess_mgr == NULL) + thread->sess_mgr_rt = session_manager_runtime_new(config->sess_mgr_cfg, now_ms); + if (thread->sess_mgr_rt == NULL) { CORE_LOG_ERROR("unable to create session manager"); return -1; @@ -366,7 +370,7 @@ static void stellar_thread_join(struct stellar *st) pthread_join(thread->tid, NULL); ip_reassembly_free(thread->ip_reass); - session_manager_free(thread->sess_mgr); + session_manager_runtime_free(thread->sess_mgr_rt); } CORE_LOG_FATAL("all worker thread exited"); } @@ -573,8 +577,8 @@ void stellar_send_build_packet(struct stellar *st, struct packet *pkt) { uint16_t thr_idx = stellar_module_manager_get_thread_id(st->runtime.mod_mgr); struct packet_io *packet_io = st->runtime.packet_io; - struct session_manager *sess_mgr = st->runtime.threads[thr_idx].sess_mgr; - session_manager_record_duplicated_packet(sess_mgr, pkt); + struct session_manager_runtime *sess_mgr_rt = st->runtime.threads[thr_idx].sess_mgr_rt; + session_manager_runtime_record_duplicated_packet(sess_mgr_rt, pkt); if (packet_get_origin_ctx(pkt)) { |