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

refactor(session manager): rename original session_manager to session_manager_runtime

Browse Source
This commit is contained in:
luwenpeng
2024-09-18 18:32:20 +08:00
parent 60caf1bda1
commit 620019cf8e
26 changed files with 1637 additions and 1552 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
infra/session_manager/test/default_config.h
View File

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

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

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

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

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

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

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

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

@@ -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);
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_free(mgr);
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);
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_free(mgr);
session_manager_runtime_free(sess_mgr_rt);
}
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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