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

Refactor the session manager using session transformation 2D array & Update test case

Browse Source
This commit is contained in:
luwenpeng
2024-03-14 10:56:09 +08:00
parent 639614622b
commit ce00122557
47 changed files with 3403 additions and 3563 deletions
Download Patch File Download Diff File Expand all files Collapse all files

131
src/session/test/CMakeLists.txt
View File

@@ -21,103 +21,94 @@ target_link_libraries(gtest_session_queue session_manager gtest)
# gtest state machine (TCP)
###############################################################################
#add_executable(gtest_state_tcp_init_to_opening gtest_state_tcp_init_to_opening.cpp)
#target_link_libraries(gtest_state_tcp_init_to_opening session_manager gtest)
#
#add_executable(gtest_state_tcp_opening_to_active gtest_state_tcp_opening_to_active.cpp)
#target_link_libraries(gtest_state_tcp_opening_to_active session_manager gtest)
#
#add_executable(gtest_state_tcp_active_to_closing gtest_state_tcp_active_to_closing.cpp)
#target_link_libraries(gtest_state_tcp_active_to_closing session_manager gtest)
#
#add_executable(gtest_state_tcp_opening_to_closing gtest_state_tcp_opening_to_closing.cpp)
#target_link_libraries(gtest_state_tcp_opening_to_closing session_manager gtest)
#
#add_executable(gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp)
#target_link_libraries(gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed session_manager gtest)
add_executable(gtest_state_tcp_init_to_opening gtest_state_tcp_init_to_opening.cpp)
target_link_libraries(gtest_state_tcp_init_to_opening session_manager gtest)
add_executable(gtest_state_tcp_opening_to_active gtest_state_tcp_opening_to_active.cpp)
target_link_libraries(gtest_state_tcp_opening_to_active session_manager gtest)
add_executable(gtest_state_tcp_active_to_closing gtest_state_tcp_active_to_closing.cpp)
target_link_libraries(gtest_state_tcp_active_to_closing session_manager gtest)
add_executable(gtest_state_tcp_opening_to_closing gtest_state_tcp_opening_to_closing.cpp)
target_link_libraries(gtest_state_tcp_opening_to_closing session_manager gtest)
add_executable(gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp)
target_link_libraries(gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed session_manager gtest)
###############################################################################
# gtest state machine (UDP)
###############################################################################
#add_executable(gtest_state_udp_init_to_opening_to_closing gtest_state_udp_init_to_opening_to_closing.cpp)
#target_link_libraries(gtest_state_udp_init_to_opening_to_closing session_manager gtest)
#
#add_executable(gtest_state_udp_init_to_opening_to_active_to_closing gtest_state_udp_init_to_opening_to_active_to_closing.cpp)
#target_link_libraries(gtest_state_udp_init_to_opening_to_active_to_closing session_manager gtest)
add_executable(gtest_state_udp_init_to_opening_to_closing gtest_state_udp_init_to_opening_to_closing.cpp)
target_link_libraries(gtest_state_udp_init_to_opening_to_closing session_manager gtest)
add_executable(gtest_state_udp_init_to_opening_to_active_to_closing gtest_state_udp_init_to_opening_to_active_to_closing.cpp)
target_link_libraries(gtest_state_udp_init_to_opening_to_active_to_closing session_manager gtest)
###############################################################################
# gtest timeout (TCP)
###############################################################################
#add_executable(gtest_timeout_tcp_init gtest_timeout_tcp_init.cpp)
#target_link_libraries(gtest_timeout_tcp_init session_manager gtest)
#
#add_executable(gtest_timeout_tcp_handshake gtest_timeout_tcp_handshake.cpp)
#target_link_libraries(gtest_timeout_tcp_handshake session_manager gtest)
#
#add_executable(gtest_timeout_tcp_data gtest_timeout_tcp_data.cpp)
#target_link_libraries(gtest_timeout_tcp_data session_manager gtest)
#
#add_executable(gtest_timeout_tcp_half_closed gtest_timeout_tcp_half_closed.cpp)
#target_link_libraries(gtest_timeout_tcp_half_closed session_manager gtest)
add_executable(gtest_timeout_tcp_init gtest_timeout_tcp_init.cpp)
target_link_libraries(gtest_timeout_tcp_init session_manager gtest)
add_executable(gtest_timeout_tcp_handshake gtest_timeout_tcp_handshake.cpp)
target_link_libraries(gtest_timeout_tcp_handshake session_manager gtest)
add_executable(gtest_timeout_tcp_data gtest_timeout_tcp_data.cpp)
target_link_libraries(gtest_timeout_tcp_data session_manager gtest)
###############################################################################
# gtest timeout (UDP)
###############################################################################
#add_executable(gtest_timeout_udp_data gtest_timeout_udp_data.cpp)
#target_link_libraries(gtest_timeout_udp_data session_manager gtest)
add_executable(gtest_timeout_udp_data gtest_timeout_udp_data.cpp)
target_link_libraries(gtest_timeout_udp_data session_manager gtest)
###############################################################################
# gtest filter
###############################################################################
#add_executable(gtest_filter_tcp_dupkt gtest_filter_tcp_dupkt.cpp)
#target_link_libraries(gtest_filter_tcp_dupkt session_manager gtest)
#
#add_executable(gtest_filter_udp_eviction gtest_filter_udp_eviction.cpp)
#target_link_libraries(gtest_filter_udp_eviction session_manager gtest)
add_executable(gtest_filter_tcp_dupkt gtest_filter_tcp_dupkt.cpp)
target_link_libraries(gtest_filter_tcp_dupkt session_manager gtest)
###############################################################################
# gtest overload
###############################################################################
#add_executable(gtest_overload_evict_tcp_sess gtest_overload_evict_tcp_sess.cpp)
#target_link_libraries(gtest_overload_evict_tcp_sess session_manager gtest)
#
#add_executable(gtest_overload_evict_udp_sess gtest_overload_evict_udp_sess.cpp)
#target_link_libraries(gtest_overload_evict_udp_sess session_manager gtest)
add_executable(gtest_overload_evict_tcp_sess gtest_overload_evict_tcp_sess.cpp)
target_link_libraries(gtest_overload_evict_tcp_sess session_manager gtest)
add_executable(gtest_overload_evict_udp_sess gtest_overload_evict_udp_sess.cpp)
target_link_libraries(gtest_overload_evict_udp_sess session_manager gtest)
###############################################################################
# gtest
###############################################################################
#include(GoogleTest)
#gtest_discover_tests(gtest_session)
#gtest_discover_tests(gtest_session_pool)
#gtest_discover_tests(gtest_session_table)
#gtest_discover_tests(gtest_session_timer)
#gtest_discover_tests(gtest_session_queue)
#
#gtest_discover_tests(gtest_state_tcp_init_to_opening)
#gtest_discover_tests(gtest_state_tcp_opening_to_active)
#gtest_discover_tests(gtest_state_tcp_active_to_closing)
#gtest_discover_tests(gtest_state_tcp_opening_to_closing)
#
#gtest_discover_tests(gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed)
#gtest_discover_tests(gtest_state_udp_init_to_opening_to_closing)
#gtest_discover_tests(gtest_state_udp_init_to_opening_to_active_to_closing)
#
#gtest_discover_tests(gtest_timeout_tcp_init)
#gtest_discover_tests(gtest_timeout_tcp_handshake)
#gtest_discover_tests(gtest_timeout_tcp_data)
#gtest_discover_tests(gtest_timeout_tcp_half_closed)
#
#gtest_discover_tests(gtest_timeout_udp_data)
#
#gtest_discover_tests(gtest_filter_tcp_dupkt)
#gtest_discover_tests(gtest_filter_udp_eviction)
#
#gtest_discover_tests(gtest_overload_evict_tcp_sess)
#gtest_discover_tests(gtest_overload_evict_udp_sess)
include(GoogleTest)
gtest_discover_tests(gtest_session)
gtest_discover_tests(gtest_session_pool)
gtest_discover_tests(gtest_session_table)
gtest_discover_tests(gtest_session_timer)
gtest_discover_tests(gtest_session_queue)
gtest_discover_tests(gtest_state_tcp_init_to_opening)
gtest_discover_tests(gtest_state_tcp_opening_to_active)
gtest_discover_tests(gtest_state_tcp_active_to_closing)
gtest_discover_tests(gtest_state_tcp_opening_to_closing)
gtest_discover_tests(gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed)
gtest_discover_tests(gtest_state_udp_init_to_opening_to_closing)
gtest_discover_tests(gtest_state_udp_init_to_opening_to_active_to_closing)
gtest_discover_tests(gtest_timeout_tcp_init)
gtest_discover_tests(gtest_timeout_tcp_handshake)
gtest_discover_tests(gtest_timeout_tcp_data)
gtest_discover_tests(gtest_timeout_udp_data)
gtest_discover_tests(gtest_filter_tcp_dupkt)
gtest_discover_tests(gtest_overload_evict_tcp_sess)
gtest_discover_tests(gtest_overload_evict_udp_sess)

393
src/session/test/gtest_filter_tcp_dupkt.cpp
View File

@@ -1,4 +1,51 @@
#include "test_utils.h"
#include <gtest/gtest.h>
#include "session.h"
#include "session_manager.h"
#include "ipv4_utils.h"
#include "test_packets.h"
struct session_manager_options opts = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_timeout_init = 1,
.tcp_timeout_handshake = 2,
.tcp_timeout_data = 3,
.tcp_timeout_half_closed = 4,
.tcp_timeout_time_wait = 5,
.tcp_timeout_discard = 6,
// udp timeout
.udp_timeout_data = 7,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_error_rate = 0.0001,
};
static void packet_set_ip_id(struct packet *pkt, uint16_t ip_id)
{
const struct layer *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_TYPE_IPV4);
EXPECT_TRUE(ipv4_layer);
struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
ipv4_hdr_set_ipid(hdr, ip_id);
}
#if 1
TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
@@ -6,277 +53,311 @@ 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;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
printf("=> packet parse: TCP C2S SYN packet\n");
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
__session_dispatch(sess);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
// C2S SYN dup Packet
printf("=> packet parse: TCP C2S SYN dup packet\n");
printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess == NULL);
__session_dispatch(sess);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == -1);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_YES);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 1);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == sizeof(tcp_pkt1_c2s_syn));
// C2S SYN retransmission Packet
printf("=> packet parse: TCP C2S SYN retransmission packet\n");
char tcp_pkt_c2s_syn_retransmission[1500] = {0};
memcpy(tcp_pkt_c2s_syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
packet_parse(&pkt, (const char *)tcp_pkt_c2s_syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
const struct layer *ipv4_layer = packet_get_innermost_layer(&pkt, LAYER_TYPE_IPV4);
EXPECT_TRUE(ipv4_layer);
struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
ipv4_hdr_set_ipid(hdr, 0x1234);
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_YES);
__session_dispatch(sess);
printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
char syn_retransmission[1500] = {0};
memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
packet_set_ip_id(&pkt, 0x1234);
printf("<= Packet Parse: done\n\n");
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_YES);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 1);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == sizeof(tcp_pkt1_c2s_syn));
session_manager_free(mgr);
}
#endif
#if 1
TEST(TCP_DUPKT_FILTER_ENABLE, S2C_DUP)
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;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// S2C SYNACK Packet
printf("=> packet parse: TCP S2C SYNACK packet\n");
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
__session_dispatch(sess);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
// S2C SYNACK dup Packet
printf("=> packet parse: TCP S2C SYNACK dup packet\n");
printf("\n=> Packet Parse: TCP S2C SYNACK dup packet\n");
packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess == NULL);
__session_dispatch(sess);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == -1);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_YES);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 1);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == sizeof(tcp_pkt2_s2c_syn_ack));
// S2C SYNACK retransmission Packet
printf("=> packet parse: TCP S2C SYNACK retransmission packet\n");
char tcp_pkt_s2c_synack_retransmission[1500] = {0};
memcpy(tcp_pkt_s2c_synack_retransmission, tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
packet_parse(&pkt, (const char *)tcp_pkt_s2c_synack_retransmission, sizeof(tcp_pkt2_s2c_syn_ack));
const struct layer *ipv4_layer = packet_get_innermost_layer(&pkt, LAYER_TYPE_IPV4);
EXPECT_TRUE(ipv4_layer);
struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
ipv4_hdr_set_ipid(hdr, 0x1234);
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("\n=> Packet Parse: TCP S2C SYNACK retransmission packet\n");
char synack_retransmission[1500] = {0};
memcpy(synack_retransmission, tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
packet_parse(&pkt, (const char *)synack_retransmission, sizeof(tcp_pkt2_s2c_syn_ack));
packet_set_ip_id(&pkt, 0x1234);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_YES);
__session_dispatch(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 1);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == sizeof(tcp_pkt2_s2c_syn_ack));
session_manager_free(mgr);
}
#endif
#if 1
TEST(TCP_DUPKT_FILTER_ENABLE, SKIP_FILTER)
TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
const struct layer *ipv4_layer;
struct ip *hdr;
char tcp_pkt_c2s_syn_retransmission[1500] = {0};
struct session_manager_stat *stat = NULL;
char syn_retransmission[1500] = {0};
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
printf("=> packet parse: TCP C2S SYN packet\n");
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
__session_dispatch(sess);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
// C2S SYN retransmission Packet
printf("=> packet parse: TCP C2S SYN retransmission packet\n");
memcpy(tcp_pkt_c2s_syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
packet_parse(&pkt, (const char *)tcp_pkt_c2s_syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
ipv4_layer = packet_get_innermost_layer(&pkt, LAYER_TYPE_IPV4);
EXPECT_TRUE(ipv4_layer);
hdr = (struct ip *)ipv4_layer->hdr_ptr;
ipv4_hdr_set_ipid(hdr, 0x1234);
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
packet_set_ip_id(&pkt, 0x1234);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
__session_dispatch(sess);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
// C2S SYN retransmission Packet
printf("=> packet parse: TCP C2S SYN retransmission packet\n");
memcpy(tcp_pkt_c2s_syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
packet_parse(&pkt, (const char *)tcp_pkt_c2s_syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
ipv4_layer = packet_get_innermost_layer(&pkt, LAYER_TYPE_IPV4);
EXPECT_TRUE(ipv4_layer);
hdr = (struct ip *)ipv4_layer->hdr_ptr;
ipv4_hdr_set_ipid(hdr, 0x1235);
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
packet_set_ip_id(&pkt, 0x1235);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
__session_dispatch(sess);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
// C2S SYN dup Packet
printf("=> packet parse: TCP C2S SYN dup packet\n");
printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess);
__session_dispatch(sess);
printf("<= Packet Parse: done\n\n");
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
session_manager_free(mgr);
}
#endif
#if 1
TEST(TCP_DUPKT_FILTER_DISABLE, C2S_DUPKT)
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_options _opts;
memcpy(&_opts, &opts, sizeof(struct session_manager_options));
_opts.tcp_dupkt_filter_enable = 0;
_opts.duplicated_packet_filter_enable = 0;
timestamp_update();
mgr = session_manager_new(&_opts);
mgr = session_manager_new(&_opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
printf("=> packet parse: TCP C2S SYN packet\n");
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
__session_dispatch(sess);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
// C2S SYN dup Packet
printf("=> packet parse: TCP C2S SYN dup packet\n");
printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess);
__session_dispatch(sess);
printf("<= Packet Parse: done\n\n");
// C2S SYN retransmission Packet
printf("=> packet parse: TCP C2S SYN retransmission packet\n");
char tcp_pkt_c2s_syn_retransmission[1500] = {0};
memcpy(tcp_pkt_c2s_syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
packet_parse(&pkt, (const char *)tcp_pkt_c2s_syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
const struct layer *ipv4_layer = packet_get_innermost_layer(&pkt, LAYER_TYPE_IPV4);
EXPECT_TRUE(ipv4_layer);
struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
ipv4_hdr_set_ipid(hdr, 0x1234);
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
__session_dispatch(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
session_manager_free(mgr);
}
#endif
#if 1
TEST(TCP_DUPKT_FILTER_DISABLE, S2C_DUP)
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_options _opts;
memcpy(&_opts, &opts, sizeof(struct session_manager_options));
_opts.tcp_dupkt_filter_enable = 0;
_opts.duplicated_packet_filter_enable = 0;
timestamp_update();
mgr = session_manager_new(&_opts);
mgr = session_manager_new(&_opts, 1);
EXPECT_TRUE(mgr != NULL);
// S2C SYNACK Packet
printf("=> packet parse: TCP S2C SYNACK packet\n");
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
__session_dispatch(sess);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
// S2C SYNACK dup Packet
printf("=> packet parse: TCP S2C SYNACK dup packet\n");
printf("\n=> Packet Parse: TCP S2C SYNACK dup packet\n");
packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess);
__session_dispatch(sess);
printf("<= Packet Parse: done\n\n");
// S2C SYNACK retransmission Packet
printf("=> packet parse: TCP S2C SYNACK retransmission packet\n");
char tcp_pkt_s2c_synack_retransmission[1500] = {0};
memcpy(tcp_pkt_s2c_synack_retransmission, tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
packet_parse(&pkt, (const char *)tcp_pkt_s2c_synack_retransmission, sizeof(tcp_pkt2_s2c_syn_ack));
const struct layer *ipv4_layer = packet_get_innermost_layer(&pkt, LAYER_TYPE_IPV4);
EXPECT_TRUE(ipv4_layer);
struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
ipv4_hdr_set_ipid(hdr, 0x1234);
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
__session_dispatch(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
session_manager_free(mgr);
}

136
src/session/test/gtest_filter_udp_eviction.cpp
View File

@@ -1,136 +0,0 @@
#include "test_utils.h"
#if 1
TEST(UDP_EVICTION_FILTER_ENABLE, HIT_FILTER_THEN_EVICT_SESS)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
EXPECT_TRUE(mgr != NULL);
// C2S REQ Packet
printf("=> packet parse: UDP C2S REQ packet\n");
packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess);
__session_dispatch(sess);
// wait session timeout
__session_manager_check_counter(mgr, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// C2S REQ Packet
printf("=> packet parse: UDP C2S REQ packet\n");
packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess == NULL);
__session_dispatch(sess);
session_manager_free(mgr);
}
#endif
#if 1
TEST(UDP_EVICTION_FILTER_ENABLE, MISS_FILTER_THEN_NEW_SESS)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_options _opts;
memcpy(&_opts, &opts, sizeof(struct session_manager_options));
_opts.udp_eviction_filter_timeout = 2;
timestamp_update();
mgr = session_manager_new(&_opts);
EXPECT_TRUE(mgr != NULL);
// C2S REQ Packet
printf("=> packet parse: UDP C2S REQ packet\n");
packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess);
__session_dispatch(sess);
// wait session timeout
__session_manager_check_counter(mgr, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// wait udp eviction filter timeout
sleep(_opts.udp_eviction_filter_timeout);
timestamp_update();
// C2S REQ Packet
printf("=> packet parse: UDP C2S REQ packet\n");
packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess); // add new udp session
__session_dispatch(sess);
__session_manager_check_counter(mgr, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
session_manager_free(mgr);
}
#endif
#if 1
TEST(UDP_EVICTION_FILTER_DISABLE, MISS_FILTER_THEN_NEW_SESS)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_options _opts;
memcpy(&_opts, &opts, sizeof(struct session_manager_options));
_opts.udp_eviction_filter_enable = 0;
timestamp_update();
mgr = session_manager_new(&_opts);
EXPECT_TRUE(mgr != NULL);
// C2S REQ Packet
printf("=> packet parse: UDP C2S REQ packet\n");
packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess);
__session_dispatch(sess);
// wait session timeout
__session_manager_check_counter(mgr, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// C2S REQ Packet
printf("=> packet parse: UDP C2S REQ packet\n");
packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess); // add new udp session
__session_dispatch(sess);
__session_manager_check_counter(mgr, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
session_manager_free(mgr);
}
#endif
int main(int argc, char **argv)
{
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

231
src/session/test/gtest_overload_evict_tcp_sess.cpp
View File

@@ -1,150 +1,155 @@
#include "test_utils.h"
#include <gtest/gtest.h>
static void overwrite_ipv4_saddr(struct packet *pkt, uint32_t saddr)
#include "session.h"
#include "session_manager.h"
#include "stellar.h"
#include "ipv4_utils.h"
#include "test_packets.h"
struct session_manager_options opts = {
// max session number
.max_tcp_session_num = RX_BURST_MAX * 2,
.max_udp_session_num = RX_BURST_MAX * 2,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_timeout_init = 1,
.tcp_timeout_handshake = 2,
.tcp_timeout_data = 3,
.tcp_timeout_half_closed = 4,
.tcp_timeout_time_wait = 5,
.tcp_timeout_discard = 6,
// udp timeout
.udp_timeout_data = 7,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_error_rate = 0.0001,
};
static void packet_set_tcp_src_addr(struct packet *pkt, uint32_t addr)
{
const struct layer *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_TYPE_IPV4);
EXPECT_TRUE(ipv4_layer);
struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
ipv4_hdr_set_src_addr(hdr, saddr);
ipv4_hdr_set_src_addr(hdr, addr);
}
#if 1
TEST(OVERLOAD, EVICT_TCP_OLD_SESS)
TEST(TCP_OVERLOAD, EVICT_TCP_OLD_SESS)
{
struct tuple6 key;
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
char buffer[1500] = {0};
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
for (uint64_t i = 0; i < opts.max_tcp_session_num; i++)
{
// C2S SYN Packet
printf("\n====================== new session (%lu) ======================\n\n", i + 1);
printf("=> packet parse: TCP C2S SYN packet\n");
memcpy(buffer, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
packet_parse(&pkt, (const char *)buffer, sizeof(tcp_pkt1_c2s_syn));
overwrite_ipv4_saddr(&pkt, i + 1);
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess);
__session_dispatch(sess);
session_manager_print_stat(mgr);
if (i == opts.max_tcp_session_num - 1)
{
__session_manager_check_counter(mgr,
i, 0, 1, // tcp_opening_sess_num, tcp_active_sess_num, tcp_closing_sess_num,
0, 0, 0, // udp_opening_sess_num, udp_active_sess_num, udp_closing_sess_num,
0, 1, // tcp_overload_evict_new_sess_num, tcp_overload_evict_old_sess_num,
0, 0); // udp_overload_evict_new_sess_num, udp_overload_evict_old_sess_num,
}
else
{
__session_manager_check_counter(mgr,
i + 1, 0, 0, // tcp_opening_sess_num, tcp_active_sess_num, tcp_closing_sess_num,
0, 0, 0, // udp_opening_sess_num, udp_active_sess_num, udp_closing_sess_num,
0, 0, // tcp_overload_evict_new_sess_num, tcp_overload_evict_old_sess_num,
0, 0); // udp_overload_evict_new_sess_num, udp_overload_evict_old_sess_num,
}
}
printf("\n====================== evicted session ======================\n\n");
// evicted oldest session
sess = session_manager_get_evicted_session(mgr);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSING);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_EVICTED);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
overwrite_ipv4_saddr(&pkt, 1);
memset(&key, 0, sizeof(struct tuple6));
packet_get_innermost_tuple6(&pkt, &key);
EXPECT_TRUE(tuple6_cmp(session_get0_key(sess), &key) == 0);
__session_dispatch(sess);
session_manager_print_stat(mgr);
printf("<= Packet Parse: done\n\n");
printf("\n====================== expired session ======================\n\n");
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
printf("\n====================== end status ======================\n\n");
// new session
for (uint32_t i = 0; i < opts.max_tcp_session_num; i++)
{
packet_set_tcp_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
}
printf("=> Session Manager: after add %lu new sessions\n", opts.max_tcp_session_num);
session_manager_print_stat(mgr);
__session_manager_check_counter(mgr,
0, 0, 0, // tcp_opening_sess_num, tcp_active_sess_num, tcp_closing_sess_num,
0, 0, 0, // udp_opening_sess_num, udp_active_sess_num, udp_closing_sess_num,
0, 1, // tcp_overload_evict_new_sess_num, tcp_overload_evict_old_sess_num,
0, 0); // udp_overload_evict_new_sess_num, udp_overload_evict_old_sess_num,
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == opts.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess.nr_sess_init == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closed == RX_BURST_MAX); // have evicted, have't free
EXPECT_TRUE(stat->tcp_sess.nr_new_sess_evicted == 0);
EXPECT_TRUE(stat->tcp_sess.nr_old_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->evc_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->evc_pkt.nr_bytes == 0);
session_manager_free(mgr);
}
#endif
#if 1
TEST(OVERLOAD, EVICT_TCP_NEW_SESS)
TEST(TCP_OVERLOAD, EVICT_TCP_NEW_SESS)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
char buffer[1500] = {0};
struct session_manager_stat *stat = NULL;
struct session_manager_options _opts;
memcpy(&_opts, &opts, sizeof(struct session_manager_options));
_opts.tcp_overload_evict_old_sess = 0;
timestamp_update();
mgr = session_manager_new(&_opts);
mgr = session_manager_new(&_opts, 1);
EXPECT_TRUE(mgr != NULL);
for (uint64_t i = 0; i <= _opts.max_tcp_session_num; i++)
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= Packet Parse: done\n\n");
// new session
for (uint32_t i = 0; i < opts.max_tcp_session_num; i++)
{
// C2S SYN Packet
printf("\n====================== new session (%lu) ======================\n\n", i + 1);
printf("=> packet parse: TCP C2S SYN packet\n");
memcpy(buffer, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
packet_parse(&pkt, (const char *)buffer, sizeof(tcp_pkt1_c2s_syn));
overwrite_ipv4_saddr(&pkt, i + 1);
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
if (i == _opts.max_tcp_session_num)
{
EXPECT_TRUE(sess == NULL);
__session_manager_check_counter(mgr,
i, 0, 0, // tcp_opening_sess_num, tcp_active_sess_num, tcp_closing_sess_num,
0, 0, 0, // udp_opening_sess_num, udp_active_sess_num, udp_closing_sess_num,
1, 0, // tcp_overload_evict_new_sess_num, tcp_overload_evict_old_sess_num,
0, 0); // udp_overload_evict_new_sess_num, udp_overload_evict_old_sess_num,
}
else
{
EXPECT_TRUE(sess);
__session_manager_check_counter(mgr,
i + 1, 0, 0, // tcp_opening_sess_num, tcp_active_sess_num, tcp_closing_sess_num,
0, 0, 0, // udp_opening_sess_num, udp_active_sess_num, udp_closing_sess_num,
0, 0, // tcp_overload_evict_new_sess_num, tcp_overload_evict_old_sess_num,
0, 0); // udp_overload_evict_new_sess_num, udp_overload_evict_old_sess_num,
}
__session_dispatch(sess);
session_manager_print_stat(mgr);
packet_set_tcp_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
}
printf("\n====================== expired session ======================\n\n");
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
printf("\n====================== end status ======================\n\n");
printf("=> Session Manager: after add %lu new sessions\n", opts.max_tcp_session_num);
session_manager_print_stat(mgr);
__session_manager_check_counter(mgr,
0, 0, 0, // tcp_opening_sess_num, tcp_active_sess_num, tcp_closing_sess_num,
0, 0, 0, // udp_opening_sess_num, udp_active_sess_num, udp_closing_sess_num,
1, 0, // tcp_overload_evict_new_sess_num, tcp_overload_evict_old_sess_num,
0, 0); // udp_overload_evict_new_sess_num, udp_overload_evict_old_sess_num,
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == opts.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess.nr_sess_init == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == opts.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closed == 0);
EXPECT_TRUE(stat->tcp_sess.nr_new_sess_evicted == 0);
EXPECT_TRUE(stat->tcp_sess.nr_old_sess_evicted == 0);
EXPECT_TRUE(stat->evc_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->evc_pkt.nr_bytes == 0);
// table full, evict new session
for (uint32_t i = 0; i < RX_BURST_MAX; i++)
{
packet_set_tcp_src_addr(&pkt, opts.max_tcp_session_num + i);
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL);
}
printf("=> Session Manager: after evicte new session\n");
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == opts.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess.nr_sess_init == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == opts.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closed == 0);
EXPECT_TRUE(stat->tcp_sess.nr_new_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->tcp_sess.nr_old_sess_evicted == 0);
EXPECT_TRUE(stat->evc_pkt.nr_pkts == RX_BURST_MAX);
EXPECT_TRUE(stat->evc_pkt.nr_bytes == RX_BURST_MAX * sizeof(tcp_pkt1_c2s_syn));
session_manager_free(mgr);
}
#endif

269
src/session/test/gtest_overload_evict_udp_sess.cpp
View File

@@ -1,150 +1,213 @@
#include "test_utils.h"
#include <gtest/gtest.h>
static void overwrite_ipv4_saddr(struct packet *pkt, uint32_t saddr)
#include "session.h"
#include "session_manager.h"
#include "stellar.h"
#include "ipv4_utils.h"
#include "test_packets.h"
struct session_manager_options opts = {
// max session number
.max_tcp_session_num = RX_BURST_MAX * 2,
.max_udp_session_num = RX_BURST_MAX * 2,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_timeout_init = 1,
.tcp_timeout_handshake = 2,
.tcp_timeout_data = 3,
.tcp_timeout_half_closed = 4,
.tcp_timeout_time_wait = 5,
.tcp_timeout_discard = 6,
// udp timeout
.udp_timeout_data = 7,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_error_rate = 0.0001,
};
static void packet_set_tcp_src_addr(struct packet *pkt, uint32_t addr)
{
const struct layer *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_TYPE_IPV4);
EXPECT_TRUE(ipv4_layer);
struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
ipv4_hdr_set_src_addr(hdr, saddr);
ipv4_hdr_set_src_addr(hdr, addr);
}
#if 1
TEST(OVERLOAD, EVICT_UDP_OLD_SESS)
TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
{
struct tuple6 key;
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
char buffer[1500] = {0};
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
for (uint64_t i = 0; i < opts.max_udp_session_num; i++)
// C2S REQ Packet
printf("\n=> Packet Parse: UDP C2S REQ packet\n");
packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
printf("<= Packet Parse: done\n\n");
// new session
for (uint32_t i = 0; i < opts.max_udp_session_num; i++)
{
// C2S REQ Packet
printf("\n====================== new session (%lu) ======================\n\n", i + 1);
printf("=> packet parse: UDP C2S REQ packet\n");
memcpy(buffer, udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
packet_parse(&pkt, (const char *)buffer, sizeof(udp_pkt1_dns_req));
overwrite_ipv4_saddr(&pkt, i + 1);
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess);
packet_set_tcp_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
}
printf("=> Session Manager: after add %lu new sessions\n", opts.max_udp_session_num);
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == opts.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess.nr_sess_init == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closed == RX_BURST_MAX); // have evicted, have't free
EXPECT_TRUE(stat->udp_sess.nr_new_sess_evicted == 0);
EXPECT_TRUE(stat->udp_sess.nr_old_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->evc_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->evc_pkt.nr_bytes == 0);
__session_dispatch(sess);
session_manager_print_stat(mgr);
if (i == opts.max_udp_session_num - 1)
// evicted session
while (1)
{
sess = session_manager_get_evicted_session(mgr);
if (sess)
{
__session_manager_check_counter(mgr,
0, 0, 0, // tcp_opening_sess_num, tcp_active_sess_num, tcp_closing_sess_num,
i, 0, 1, // udp_opening_sess_num, udp_active_sess_num, udp_closing_sess_num,
0, 0, // tcp_overload_evict_new_sess_num, tcp_overload_evict_old_sess_num,
0, 1); // udp_overload_evict_new_sess_num, udp_overload_evict_old_sess_num,
session_manager_free_session(mgr, sess);
}
else
{
__session_manager_check_counter(mgr,
0, 0, 0, // tcp_opening_sess_num, tcp_active_sess_num, tcp_closing_sess_num,
i + 1, 0, 0, // udp_opening_sess_num, udp_active_sess_num, udp_closing_sess_num,
0, 0, // tcp_overload_evict_new_sess_num, tcp_overload_evict_old_sess_num,
0, 0); // udp_overload_evict_new_sess_num, udp_overload_evict_old_sess_num,
break;
}
}
printf("\n====================== evicted session ======================\n\n");
// evicted oldest session
sess = session_manager_get_evicted_session(mgr);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSING);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_EVICTED);
packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
overwrite_ipv4_saddr(&pkt, 1);
memset(&key, 0, sizeof(struct tuple6));
packet_get_innermost_tuple6(&pkt, &key);
EXPECT_TRUE(tuple6_cmp(session_get0_key(sess), &key) == 0);
__session_dispatch(sess);
for (uint32_t i = 0; i < RX_BURST_MAX; i++)
{
packet_set_tcp_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL); // hit evicted session, can't renew session
}
printf("=> Session Manager: after readd %d evicted sessions\n", RX_BURST_MAX);
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_sess.nr_sess_init == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closed == 0);
EXPECT_TRUE(stat->udp_sess.nr_new_sess_evicted == 0);
EXPECT_TRUE(stat->udp_sess.nr_old_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->evc_pkt.nr_pkts == RX_BURST_MAX);
EXPECT_TRUE(stat->evc_pkt.nr_bytes == RX_BURST_MAX * sizeof(udp_pkt1_dns_req));
printf("\n====================== expired session ======================\n\n");
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
printf("\n====================== end status ======================\n\n");
// evicted session timeout
packet_set_tcp_src_addr(&pkt, 0);
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1 + opts.evicted_session_filter_timeout));
printf("=> Session Manager: after evicted session timeout\n");
session_manager_print_stat(mgr);
__session_manager_check_counter(mgr,
0, 0, 0, // tcp_opening_sess_num, tcp_active_sess_num, tcp_closing_sess_num,
0, 0, 0, // udp_opening_sess_num, udp_active_sess_num, udp_closing_sess_num,
0, 0, // tcp_overload_evict_new_sess_num, tcp_overload_evict_old_sess_num,
0, 1); // udp_overload_evict_new_sess_num, udp_overload_evict_old_sess_num,
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == RX_BURST_MAX + 1);
EXPECT_TRUE(stat->udp_sess.nr_sess_init == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closed == 1); // have evicted, have't free
EXPECT_TRUE(stat->udp_sess.nr_new_sess_evicted == 0);
EXPECT_TRUE(stat->udp_sess.nr_old_sess_evicted == RX_BURST_MAX + 1);
EXPECT_TRUE(stat->evc_pkt.nr_pkts == RX_BURST_MAX);
EXPECT_TRUE(stat->evc_pkt.nr_bytes == RX_BURST_MAX * sizeof(udp_pkt1_dns_req));
session_manager_free(mgr);
}
#endif
#if 1
TEST(OVERLOAD, EVICT_UDP_NEW_SESS)
TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
char buffer[1500] = {0};
struct session_manager_stat *stat = NULL;
struct session_manager_options _opts;
memcpy(&_opts, &opts, sizeof(struct session_manager_options));
_opts.udp_overload_evict_old_sess = 0;
timestamp_update();
mgr = session_manager_new(&_opts);
mgr = session_manager_new(&_opts, 1);
EXPECT_TRUE(mgr != NULL);
for (uint64_t i = 0; i <= _opts.max_udp_session_num; i++)
// C2S REQ Packet
printf("\n=> Packet Parse: UDP C2S REQ packet\n");
packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
printf("<= Packet Parse: done\n\n");
// new session
for (uint32_t i = 0; i < opts.max_udp_session_num; i++)
{
// C2S REQ Packet
printf("\n====================== new session (%lu) ======================\n\n", i + 1);
printf("=> packet parse: UDP C2S REQ packet\n");
memcpy(buffer, udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
packet_parse(&pkt, (const char *)buffer, sizeof(udp_pkt1_dns_req));
overwrite_ipv4_saddr(&pkt, i + 1);
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
if (i == _opts.max_udp_session_num)
{
EXPECT_TRUE(sess == NULL);
__session_manager_check_counter(mgr,
0, 0, 0, // tcp_opening_sess_num, tcp_active_sess_num, tcp_closing_sess_num,
i, 0, 0, // udp_opening_sess_num, udp_active_sess_num, udp_closing_sess_num,
0, 0, // tcp_overload_evict_new_sess_num, tcp_overload_evict_old_sess_num,
1, 0); // udp_overload_evict_new_sess_num, udp_overload_evict_old_sess_num,
}
else
{
EXPECT_TRUE(sess);
__session_manager_check_counter(mgr,
0, 0, 0, // tcp_opening_sess_num, tcp_active_sess_num, tcp_closing_sess_num,
i + 1, 0, 0, // udp_opening_sess_num, udp_active_sess_num, udp_closing_sess_num,
0, 0, // tcp_overload_evict_new_sess_num, tcp_overload_evict_old_sess_num,
0, 0); // udp_overload_evict_new_sess_num, udp_overload_evict_old_sess_num,
}
__session_dispatch(sess);
session_manager_print_stat(mgr);
packet_set_tcp_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
}
printf("\n====================== expired session ======================\n\n");
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
printf("\n====================== end status ======================\n\n");
printf("=> Session Manager: after add %lu new sessions\n", opts.max_udp_session_num);
session_manager_print_stat(mgr);
__session_manager_check_counter(mgr,
0, 0, 0, // tcp_opening_sess_num, tcp_active_sess_num, tcp_closing_sess_num,
0, 0, 0, // udp_opening_sess_num, udp_active_sess_num, udp_closing_sess_num,
0, 0, // tcp_overload_evict_new_sess_num, tcp_overload_evict_old_sess_num,
1, 0); // udp_overload_evict_new_sess_num, udp_overload_evict_old_sess_num,
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == opts.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess.nr_sess_init == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == opts.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closed == 0);
EXPECT_TRUE(stat->udp_sess.nr_new_sess_evicted == 0);
EXPECT_TRUE(stat->udp_sess.nr_old_sess_evicted == 0);
EXPECT_TRUE(stat->evc_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->evc_pkt.nr_bytes == 0);
// evicted session
EXPECT_TRUE(session_manager_get_evicted_session(mgr) == NULL);
// table full, evict new session
for (uint32_t i = 0; i < RX_BURST_MAX; i++)
{
packet_set_tcp_src_addr(&pkt, opts.max_udp_session_num + i);
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL);
}
printf("=> Session Manager: after readd %d evicted session\n", RX_BURST_MAX);
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == opts.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess.nr_sess_init == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == opts.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closed == 0);
EXPECT_TRUE(stat->udp_sess.nr_new_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_sess.nr_old_sess_evicted == 0);
EXPECT_TRUE(stat->evc_pkt.nr_pkts == RX_BURST_MAX);
EXPECT_TRUE(stat->evc_pkt.nr_bytes == RX_BURST_MAX * sizeof(udp_pkt1_dns_req));
session_manager_free(mgr);
}
#endif

76
src/session/test/gtest_session_table.cpp
View File

@@ -89,37 +89,37 @@ TEST(SESSION_TABLE, OP_SESSION)
session_set_id(sess3, 3);
session_set_key(sess3, &tuple_3);
EXPECT_TRUE(session_table_add_session(sess_table, &tuple_1, sess1) == 0);
EXPECT_TRUE(session_table_add(sess_table, &tuple_1, sess1) == 0);
EXPECT_TRUE(session_table_get_count(sess_table) == 1);
EXPECT_TRUE(session_table_add_session(sess_table, &tuple_2, sess2) == 0);
EXPECT_TRUE(session_table_add(sess_table, &tuple_2, sess2) == 0);
EXPECT_TRUE(session_table_get_count(sess_table) == 2);
EXPECT_TRUE(session_table_add_session(sess_table, &tuple_3, sess3) == 0);
EXPECT_TRUE(session_table_add(sess_table, &tuple_3, sess3) == 0);
EXPECT_TRUE(session_table_get_count(sess_table) == 3);
// Search
EXPECT_TRUE(session_table_find_session(sess_table, &tuple_1) == sess1);
EXPECT_TRUE(session_table_find_session(sess_table, &tuple_2) == sess2);
EXPECT_TRUE(session_table_find_session(sess_table, &tuple_3) == sess3);
EXPECT_TRUE(session_table_find_tuple(sess_table, &tuple_1) == sess1);
EXPECT_TRUE(session_table_find_tuple(sess_table, &tuple_2) == sess2);
EXPECT_TRUE(session_table_find_tuple(sess_table, &tuple_3) == sess3);
EXPECT_TRUE(session_table_find_session(sess_table, &reversed_tuple_1) == sess1);
EXPECT_TRUE(session_table_find_session(sess_table, &reversed_tuple_2) == sess2);
EXPECT_TRUE(session_table_find_session(sess_table, &reversed_tuple_3) == sess3);
EXPECT_TRUE(session_table_find_tuple(sess_table, &reversed_tuple_1) == sess1);
EXPECT_TRUE(session_table_find_tuple(sess_table, &reversed_tuple_2) == sess2);
EXPECT_TRUE(session_table_find_tuple(sess_table, &reversed_tuple_3) == sess3);
// Delete
session_table_del_session(sess_table, &tuple_1);
session_table_del(sess_table, &tuple_1);
EXPECT_TRUE(session_table_get_count(sess_table) == 2);
EXPECT_TRUE(session_table_find_session(sess_table, &tuple_1) == NULL);
EXPECT_TRUE(session_table_find_session(sess_table, &reversed_tuple_1) == NULL);
EXPECT_TRUE(session_table_find_tuple(sess_table, &tuple_1) == NULL);
EXPECT_TRUE(session_table_find_tuple(sess_table, &reversed_tuple_1) == NULL);
session_table_del_session(sess_table, &reversed_tuple_2);
session_table_del(sess_table, &reversed_tuple_2);
EXPECT_TRUE(session_table_get_count(sess_table) == 1);
EXPECT_TRUE(session_table_find_session(sess_table, &tuple_2) == NULL);
EXPECT_TRUE(session_table_find_session(sess_table, &reversed_tuple_2) == NULL);
EXPECT_TRUE(session_table_find_tuple(sess_table, &tuple_2) == NULL);
EXPECT_TRUE(session_table_find_tuple(sess_table, &reversed_tuple_2) == NULL);
session_table_del_session(sess_table, &tuple_3);
session_table_del(sess_table, &tuple_3);
EXPECT_TRUE(session_table_get_count(sess_table) == 0);
EXPECT_TRUE(session_table_find_session(sess_table, &tuple_3) == NULL);
EXPECT_TRUE(session_table_find_session(sess_table, &reversed_tuple_3) == NULL);
EXPECT_TRUE(session_table_find_tuple(sess_table, &tuple_3) == NULL);
EXPECT_TRUE(session_table_find_tuple(sess_table, &reversed_tuple_3) == NULL);
// Destroy
session_table_free(sess_table);
@@ -147,46 +147,46 @@ TEST(SESSION_TABLE, FIND_OLDEST_NEWEST)
// Add Session
EXPECT_TRUE(session_table_find_least_recently_unused_session(sess_table) == NULL);
EXPECT_TRUE(session_table_find_least_recently_used_session(sess_table) == NULL);
EXPECT_TRUE(session_table_find_lru(sess_table) == NULL);
EXPECT_TRUE(session_table_find_mru(sess_table) == NULL);
sess1 = session_pool_pop(sess_pool);
EXPECT_TRUE(sess1 != NULL);
session_set_id(sess1, 1);
session_set_key(sess1, &tuple_1);
EXPECT_TRUE(session_table_add_session(sess_table, &tuple_1, sess1) == 0);
EXPECT_TRUE(session_table_find_least_recently_unused_session(sess_table) == sess1);
EXPECT_TRUE(session_table_find_least_recently_used_session(sess_table) == sess1);
EXPECT_TRUE(session_table_add(sess_table, &tuple_1, sess1) == 0);
EXPECT_TRUE(session_table_find_lru(sess_table) == sess1);
EXPECT_TRUE(session_table_find_mru(sess_table) == sess1);
sess2 = session_pool_pop(sess_pool);
EXPECT_TRUE(sess2 != NULL);
session_set_id(sess2, 2);
session_set_key(sess2, &tuple_2);
EXPECT_TRUE(session_table_add_session(sess_table, &tuple_2, sess2) == 0);
EXPECT_TRUE(session_table_find_least_recently_unused_session(sess_table) == sess1);
EXPECT_TRUE(session_table_find_least_recently_used_session(sess_table) == sess2);
EXPECT_TRUE(session_table_add(sess_table, &tuple_2, sess2) == 0);
EXPECT_TRUE(session_table_find_lru(sess_table) == sess1);
EXPECT_TRUE(session_table_find_mru(sess_table) == sess2);
sess3 = session_pool_pop(sess_pool);
EXPECT_TRUE(sess3 != NULL);
session_set_id(sess3, 3);
session_set_key(sess3, &tuple_3);
EXPECT_TRUE(session_table_add_session(sess_table, &tuple_3, sess3) == 0);
EXPECT_TRUE(session_table_find_least_recently_unused_session(sess_table) == sess1);
EXPECT_TRUE(session_table_find_least_recently_used_session(sess_table) == sess3);
EXPECT_TRUE(session_table_add(sess_table, &tuple_3, sess3) == 0);
EXPECT_TRUE(session_table_find_lru(sess_table) == sess1);
EXPECT_TRUE(session_table_find_mru(sess_table) == sess3);
// Delete Session
session_table_del_session(sess_table, &tuple_1);
EXPECT_TRUE(session_table_find_least_recently_unused_session(sess_table) == sess2);
EXPECT_TRUE(session_table_find_least_recently_used_session(sess_table) == sess3);
session_table_del(sess_table, &tuple_1);
EXPECT_TRUE(session_table_find_lru(sess_table) == sess2);
EXPECT_TRUE(session_table_find_mru(sess_table) == sess3);
session_table_del_session(sess_table, &tuple_2);
EXPECT_TRUE(session_table_find_least_recently_unused_session(sess_table) == sess3);
EXPECT_TRUE(session_table_find_least_recently_used_session(sess_table) == sess3);
session_table_del(sess_table, &tuple_2);
EXPECT_TRUE(session_table_find_lru(sess_table) == sess3);
EXPECT_TRUE(session_table_find_mru(sess_table) == sess3);
session_table_del_session(sess_table, &tuple_3);
EXPECT_TRUE(session_table_find_least_recently_unused_session(sess_table) == NULL);
EXPECT_TRUE(session_table_find_least_recently_used_session(sess_table) == NULL);
session_table_del(sess_table, &tuple_3);
EXPECT_TRUE(session_table_find_lru(sess_table) == NULL);
EXPECT_TRUE(session_table_find_mru(sess_table) == NULL);
// Destroy
session_table_free(sess_table);

50
src/session/test/gtest_session_timer.cpp
View File

@@ -18,8 +18,8 @@ TEST(SESSION_TIMER, ADD_DEL)
session_set_id(&sess, 1);
session_set_expirecb(&sess, session_expire, NULL, 1000);
session_timer_add_session(timer, &sess);
session_timer_del_session(timer, &sess);
session_timer_add(timer, &sess);
session_timer_del(timer, &sess);
session_timer_free(timer);
}
@@ -43,16 +43,16 @@ TEST(SESSION_TIMER, EXPIRE)
session_set_expirecb(&sess2, session_expire, NULL, 5);
session_set_expirecb(&sess3, session_expire, NULL, 10);
session_timer_add_session(timer, &sess1);
session_timer_add_session(timer, &sess2);
session_timer_add_session(timer, &sess3);
session_timer_add(timer, &sess1);
session_timer_add(timer, &sess2);
session_timer_add(timer, &sess3);
for (uint64_t abs_current_ts = 0; abs_current_ts < 15; abs_current_ts++)
{
printf("current timestamp %lu\n", abs_current_ts);
do
{
sess = session_timer_expire_session(timer, abs_current_ts);
sess = session_timer_expire(timer, abs_current_ts);
if (sess != NULL)
{
session_run_expirecb(sess);
@@ -82,9 +82,9 @@ TEST(SESSION_TIMER, BEFORE_EXPIRE_DEL)
session_set_expirecb(&sess2, session_expire, NULL, 5);
session_set_expirecb(&sess3, session_expire, NULL, 10);
session_timer_add_session(timer, &sess1);
session_timer_add_session(timer, &sess2);
session_timer_add_session(timer, &sess3);
session_timer_add(timer, &sess1);
session_timer_add(timer, &sess2);
session_timer_add(timer, &sess3);
for (uint64_t abs_current_ts = 0; abs_current_ts < 15; abs_current_ts++)
{
@@ -92,11 +92,11 @@ TEST(SESSION_TIMER, BEFORE_EXPIRE_DEL)
if (abs_current_ts == 2)
{
printf("delete timer 2\n");
session_timer_del_session(timer, &sess2);
session_timer_del(timer, &sess2);
}
do
{
sess = session_timer_expire_session(timer, abs_current_ts);
sess = session_timer_expire(timer, abs_current_ts);
if (sess != NULL)
{
session_run_expirecb(sess);
@@ -126,9 +126,9 @@ TEST(SESSION_TIMER, BEFORE_EXPIRE_UPDATE)
session_set_expirecb(&sess2, session_expire, NULL, 5);
session_set_expirecb(&sess3, session_expire, NULL, 10);
session_timer_add_session(timer, &sess1);
session_timer_add_session(timer, &sess2);
session_timer_add_session(timer, &sess3);
session_timer_add(timer, &sess1);
session_timer_add(timer, &sess2);
session_timer_add(timer, &sess3);
for (uint64_t abs_current_ts = 0; abs_current_ts < 15; abs_current_ts++)
{
@@ -136,13 +136,13 @@ TEST(SESSION_TIMER, BEFORE_EXPIRE_UPDATE)
if (abs_current_ts == 2)
{
printf("update timer 2\n");
session_timer_del_session(timer, &sess2);
session_timer_del(timer, &sess2);
session_set_expirecb(&sess2, session_expire, NULL, 8);
session_timer_add_session(timer, &sess2);
session_timer_add(timer, &sess2);
}
do
{
sess = session_timer_expire_session(timer, abs_current_ts);
sess = session_timer_expire(timer, abs_current_ts);
if (sess != NULL)
{
session_run_expirecb(sess);
@@ -169,26 +169,26 @@ TEST(SESSION_TIMER, NEXT_EXPIRE_INTERVAL)
EXPECT_TRUE(session_timer_next_expire_interval(timer) == UINT64_MAX);
session_timer_add_session(timer, &sess1);
session_timer_add_session(timer, &sess2);
session_timer_add(timer, &sess1);
session_timer_add(timer, &sess2);
EXPECT_TRUE(session_timer_next_expire_interval(timer) < UINT64_MAX);
EXPECT_TRUE(session_timer_expire_session(timer, 900) == NULL);
EXPECT_TRUE(session_timer_expire(timer, 900) == NULL);
EXPECT_TRUE(session_timer_next_expire_interval(timer) <= 1000 - 900);
EXPECT_TRUE(session_timer_expire_session(timer, 950) == NULL);
EXPECT_TRUE(session_timer_expire(timer, 950) == NULL);
EXPECT_TRUE(session_timer_next_expire_interval(timer) <= 1000 - 950);
EXPECT_TRUE(session_timer_expire_session(timer, 980) == NULL);
EXPECT_TRUE(session_timer_expire(timer, 980) == NULL);
EXPECT_TRUE(session_timer_next_expire_interval(timer) <= 1000 - 980);
EXPECT_TRUE(session_timer_expire_session(timer, 990) == NULL);
EXPECT_TRUE(session_timer_expire(timer, 990) == NULL);
EXPECT_TRUE(session_timer_next_expire_interval(timer) <= 1000 - 990);
EXPECT_TRUE(session_timer_expire_session(timer, 1010));
EXPECT_TRUE(session_timer_expire(timer, 1010));
EXPECT_TRUE(session_timer_next_expire_interval(timer) == 0);
EXPECT_TRUE(session_timer_expire_session(timer, 1010));
EXPECT_TRUE(session_timer_expire(timer, 1010));
EXPECT_TRUE(session_timer_next_expire_interval(timer) == UINT64_MAX);
session_timer_free(timer);

442
src/session/test/gtest_state_tcp_active_to_closing.cpp
View File

@@ -1,80 +1,70 @@
// TCP state machine test: active -> closing
#include <gtest/gtest.h>
#include "test_utils.h"
#include "session.h"
#include "session_manager.h"
#include "tcp_utils.h"
#include "test_packets.h"
struct session_manager_options opts = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_timeout_init = 1,
.tcp_timeout_handshake = 2,
.tcp_timeout_data = 3,
.tcp_timeout_half_closed = 4,
.tcp_timeout_time_wait = 5,
.tcp_timeout_discard = 6,
// udp timeout
.udp_timeout_data = 7,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_error_rate = 0.0001,
};
static void build_active_tcp_session(struct session_manager *mgr, struct session *sess)
{
char buffer[1024] = {0};
struct packet pkt;
// C2S SYN Packet
printf("=> packet parse: TCP C2S SYN packet\n");
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_c2s_bytes(sess) == 78);
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYN_RECVED);
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
__session_dispatch(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// C2S DATA Packet
printf("=> packet parse: TCP C2S DATA packet\n");
printf("\n=> Packet Parse: TCP C2S DATA packet\n");
packet_parse(&pkt, (const char *)tcp_pkt4_c2s_http_req, sizeof(tcp_pkt4_c2s_http_req));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_ACTIVE);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_c2s_bytes(sess) == 78 + 145);
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_C2S_ACK_RECVED | TCP_C2S_DATA_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
__session_dispatch(sess);
__session_manager_check_counter(mgr, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
}
/******************************************************************************
@@ -88,55 +78,35 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet & C2S DATA Packet
build_active_tcp_session(mgr, sess);
// C2S FIN Packet
printf("=> packet parse: TCP C2S FIN packet\n");
printf("\n=> Packet Parse: TCP C2S FIN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt9_c2s_fin, sizeof(tcp_pkt9_c2s_fin));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_ACTIVE);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
EXPECT_TRUE(session_get_c2s_bytes(sess) == 78 + 145 + 66);
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_C2S_ACK_RECVED | TCP_C2S_DATA_RECVED | TCP_C2S_FIN_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
__session_dispatch(sess);
__session_manager_check_counter(mgr, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
// S2C FIN Packet
printf("=> packet parse: TCP S2C FIN packet\n");
printf("\n=> Packet Parse: TCP S2C FIN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt10_s2c_fin, sizeof(tcp_pkt10_s2c_fin));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
@@ -150,19 +120,40 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 66);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 3);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_C2S_ACK_RECVED | TCP_S2C_ACK_RECVED | TCP_C2S_DATA_RECVED | TCP_C2S_FIN_RECVED | TCP_S2C_FIN_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
__session_manager_check_counter(mgr, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_CLIENT_FIN);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -179,17 +170,16 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet & C2S DATA Packet
build_active_tcp_session(mgr, sess);
// C2S RST Packet
printf("=> packet parse: TCP C2S RST packet\n");
printf("\n=> Packet Parse: TCP C2S RST packet\n");
char tcp_pkt_c2s_rst[1500] = {0};
memcpy(tcp_pkt_c2s_rst, tcp_pkt9_c2s_fin, sizeof(tcp_pkt9_c2s_fin));
packet_parse(&pkt, (const char *)tcp_pkt_c2s_rst, sizeof(tcp_pkt9_c2s_fin));
@@ -198,9 +188,13 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr;
tcp_hdr_set_flags(hdr, 0);
tcp_hdr_set_rst_flag(hdr, true);
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
@@ -214,19 +208,40 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 3);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_C2S_ACK_RECVED | TCP_C2S_DATA_RECVED | TCP_C2S_RST_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
__session_manager_check_counter(mgr, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_CLIENT_RST);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -243,17 +258,16 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet & C2S DATA Packet
build_active_tcp_session(mgr, sess);
// S2C RST Packet
printf("=> packet parse: TCP S2C RST packet\n");
printf("\n=> Packet Parse: TCP S2C RST packet\n");
char tcp_pkt_s2c_rst[1500] = {0};
memcpy(tcp_pkt_s2c_rst, tcp_pkt10_s2c_fin, sizeof(tcp_pkt10_s2c_fin));
packet_parse(&pkt, (const char *)tcp_pkt_s2c_rst, sizeof(tcp_pkt10_s2c_fin));
@@ -262,9 +276,13 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr;
tcp_hdr_set_flags(hdr, 0);
tcp_hdr_set_rst_flag(hdr, true);
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
@@ -278,19 +296,40 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 66);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 3);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_C2S_ACK_RECVED | TCP_C2S_DATA_RECVED | TCP_S2C_RST_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
__session_manager_check_counter(mgr, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_SERVER_RST);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -305,18 +344,41 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
{
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet & C2S DATA Packet
build_active_tcp_session(mgr, sess);
__session_manager_check_counter(mgr, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_data) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_data + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -333,27 +395,30 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet & C2S DATA Packet
build_active_tcp_session(mgr, sess);
// C2S FIN Packet
printf("=> packet parse: TCP C2S FIN packet\n");
printf("\n=> Packet Parse: TCP C2S FIN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt9_c2s_fin, sizeof(tcp_pkt9_c2s_fin));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_ACTIVE);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSING);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
@@ -361,19 +426,40 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 3);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_C2S_ACK_RECVED | TCP_C2S_DATA_RECVED | TCP_C2S_FIN_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
__session_manager_check_counter(mgr, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_CLIENT_FIN);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -390,27 +476,30 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet & C2S DATA Packet
build_active_tcp_session(mgr, sess);
// S2C FIN Packet
printf("=> packet parse: TCP S2C FIN packet\n");
printf("\n=> Packet Parse: TCP S2C FIN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt10_s2c_fin, sizeof(tcp_pkt10_s2c_fin));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_ACTIVE);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSING);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
@@ -418,19 +507,40 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 66);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 3);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_C2S_ACK_RECVED | TCP_S2C_ACK_RECVED | TCP_C2S_DATA_RECVED | TCP_S2C_FIN_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
__session_manager_check_counter(mgr, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_SERVER_FIN);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}

737
src/session/test/gtest_state_tcp_init_to_opening.cpp
View File

@@ -1,6 +1,44 @@
// TCP state machine test: init -> opening
#include <gtest/gtest.h>
#include "test_utils.h"
#include "session.h"
#include "session_manager.h"
#include "ipv4_utils.h"
#include "test_packets.h"
struct session_manager_options opts = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_timeout_init = 1,
.tcp_timeout_handshake = 2,
.tcp_timeout_data = 3,
.tcp_timeout_half_closed = 4,
.tcp_timeout_time_wait = 5,
.tcp_timeout_discard = 6,
// udp timeout
.udp_timeout_data = 7,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_error_rate = 0.0001,
};
/******************************************************************************
* case: TCP init -> opening (by SYN)
@@ -13,17 +51,20 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
printf("=> packet parse: TCP C2S SYN packet\n");
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
@@ -38,20 +79,42 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 1);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYN_RECVED);
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_timeout_init) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + opts.tcp_timeout_init + opts.tcp_timeout_time_wait); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -68,17 +131,20 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// SYNACK Packet
printf("=> packet parse: TCP S2C SYNACK packet\n");
// S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
@@ -93,20 +159,42 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
EXPECT_TRUE(session_get_c2s_packets(sess) == 0);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 1);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYNACK_RECVED);
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_s2c_1st_pkt(sess));
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_timeout_handshake) == NULL);
sess = session_manager_get_expired_session(mgr, 1 + opts.tcp_timeout_handshake + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -123,53 +211,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
printf("=> packet parse: TCP C2S SYN packet\n");
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_c2s_bytes(sess) == 78);
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYN_RECVED);
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
__session_dispatch(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// SYNACK Packet
printf("=> packet parse: TCP S2C SYNACK packet\n");
// S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
@@ -183,20 +250,42 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 2);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_handshake) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_handshake + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -213,88 +302,43 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
printf("=> packet parse: TCP C2S SYN packet\n");
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_c2s_bytes(sess) == 78);
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYN_RECVED);
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
__session_dispatch(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// SYNACK Packet
printf("=> packet parse: TCP S2C SYNACK packet\n");
// S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_c2s_bytes(sess) == 78);
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
__session_dispatch(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// ACK Packet
printf("=> packet parse: TCP C2S ACK packet\n");
// C2S ACK Packet
printf("\n=> Packet Parse: TCP C2S ACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt3_c2s_ack, sizeof(tcp_pkt3_c2s_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
@@ -308,19 +352,41 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 3);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED | TCP_C2S_ACK_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + opts.tcp_timeout_data) == NULL);
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_timeout_data + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -339,59 +405,37 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
printf("=> packet parse: TCP C2S SYN packet\n");
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_c2s_bytes(sess) == 78);
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYN_RECVED);
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
__session_dispatch(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// C2S SYN Packet retransmission
printf("=> packet parse: TCP C2S SYN retransmission packet\n");
char tcp_pkt_c2s_syn_retransmission[1500] = {0};
memcpy(tcp_pkt_c2s_syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
packet_parse(&pkt, (const char *)tcp_pkt_c2s_syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
char syn_retransmission[1500] = {0};
memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
const struct layer *ipv4_layer = packet_get_innermost_layer(&pkt, LAYER_TYPE_IPV4);
EXPECT_TRUE(ipv4_layer);
struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
ipv4_hdr_set_ipid(hdr, 0x1234);
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
@@ -405,20 +449,42 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 2);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYN_RECVED);
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_init) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_init + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -437,49 +503,24 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// SYNACK Packet
printf("=> packet parse: TCP S2C SYNACK packet\n");
// S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "93.184.216.34:80 -> 192.168.38.105:60111, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_c2s_bytes(sess) == 0);
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
EXPECT_TRUE(session_get_c2s_packets(sess) == 0);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYNACK_RECVED);
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_s2c_1st_pkt(sess));
__session_dispatch(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// SYNACK Packet retransmission
printf("=> packet parse: TCP S2C SYNACK retransmission packet\n");
printf("\n=> Packet Parse: TCP S2C SYNACK retransmission packet\n");
char tcp_pkt_s2c_synack_retransmission[1500] = {0};
memcpy(tcp_pkt_s2c_synack_retransmission, tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
packet_parse(&pkt, (const char *)tcp_pkt_s2c_synack_retransmission, sizeof(tcp_pkt2_s2c_syn_ack));
@@ -487,9 +528,13 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
EXPECT_TRUE(ipv4_layer);
struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
ipv4_hdr_set_ipid(hdr, 0x1234);
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
@@ -503,20 +548,42 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74 + 74);
EXPECT_TRUE(session_get_c2s_packets(sess) == 0);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1 + 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 2);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYNACK_RECVED);
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_s2c_1st_pkt(sess));
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_handshake) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_handshake + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -533,53 +600,32 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
printf("=> packet parse: TCP C2S SYN packet\n");
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_c2s_bytes(sess) == 78);
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYN_RECVED);
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
__session_dispatch(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// ACK Packet
printf("=> packet parse: TCP C2S ACK packet\n");
// C2S ACK Packet
printf("\n=> Packet Parse: TCP C2S ACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt3_c2s_ack, sizeof(tcp_pkt3_c2s_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
@@ -593,20 +639,42 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 2);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_C2S_ACK_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_data) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_data + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -623,53 +691,32 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// SYNACK Packet
printf("=> packet parse: TCP S2C SYNACK packet\n");
// S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "93.184.216.34:80 -> 192.168.38.105:60111, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_c2s_bytes(sess) == 0);
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
EXPECT_TRUE(session_get_c2s_packets(sess) == 0);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYNACK_RECVED);
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_s2c_1st_pkt(sess));
__session_dispatch(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// ACK Packet
printf("=> packet parse: TCP S2C ACK packet\n");
// S2C ACK Packet
printf("\n=> Packet Parse: TCP S2C ACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt5_s2c_ack, sizeof(tcp_pkt5_s2c_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
@@ -683,20 +730,42 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74 + 66);
EXPECT_TRUE(session_get_c2s_packets(sess) == 0);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1 + 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 2);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYNACK_RECVED | TCP_S2C_ACK_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_s2c_1st_pkt(sess));
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_data) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_data + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}

311
src/session/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
View File

@@ -1,6 +1,43 @@
// TCP state machine test: init -> opening -> active -> closing -> closed
#include <gtest/gtest.h>
#include "test_utils.h"
#include "session.h"
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_timeout_init = 1,
.tcp_timeout_handshake = 2,
.tcp_timeout_data = 3,
.tcp_timeout_half_closed = 4,
.tcp_timeout_time_wait = 5,
.tcp_timeout_discard = 6,
// udp timeout
.udp_timeout_data = 7,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_error_rate = 0.0001,
};
#if 1
TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
@@ -9,17 +46,20 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
printf("=> packet parse: TCP C2S SYN packet\n");
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
@@ -35,28 +75,23 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 1);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYN_RECVED);
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
__session_dispatch(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// S2C SYNACK Packet
printf("=> packet parse: TCP S2C SYNACK packet\n");
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -71,27 +106,23 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 2);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
__session_dispatch(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// C2S ACK Packet
printf("=> packet parse: TCP C2S ACK packet\n");
printf("\n=> Packet Parse: TCP C2S ACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt3_c2s_ack, sizeof(tcp_pkt3_c2s_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -106,27 +137,23 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 3);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED | TCP_C2S_ACK_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
__session_dispatch(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// C2S REQ Packet
printf("=> packet parse: TCP C2S REQ packet\n");
printf("\n=> Packet Parse: TCP C2S REQ packet\n");
packet_parse(&pkt, (const char *)tcp_pkt4_c2s_http_req, sizeof(tcp_pkt4_c2s_http_req));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 4) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -141,27 +168,23 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 4);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED | TCP_C2S_ACK_RECVED | TCP_C2S_DATA_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
__session_dispatch(sess);
__session_manager_check_counter(mgr, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// S2C ACK Packet
printf("=> packet parse: TCP S2C ACK packet\n");
printf("\n=> Packet Parse: TCP S2C ACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt5_s2c_ack, sizeof(tcp_pkt5_s2c_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 5) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -176,27 +199,23 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74 + 66);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1 + 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 5);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED | TCP_C2S_ACK_RECVED | TCP_S2C_ACK_RECVED | TCP_C2S_DATA_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
__session_dispatch(sess);
__session_manager_check_counter(mgr, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// S2C HTTP Resp Packet1
printf("=> packet parse: TCP S2C Resp packet1\n");
printf("\n=> Packet Parse: TCP S2C Resp packet1\n");
packet_parse(&pkt, (const char *)tcp_pkt6_s2c_http_resq_1, sizeof(tcp_pkt6_s2c_http_resq_1));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 6) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -211,27 +230,23 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74 + 66 + 1354);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1 + 1 + 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 6);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED | TCP_C2S_ACK_RECVED | TCP_S2C_ACK_RECVED | TCP_C2S_DATA_RECVED | TCP_S2C_DATA_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
__session_dispatch(sess);
__session_manager_check_counter(mgr, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// S2C HTTP Resp Packet2
printf("=> packet parse: TCP S2C Resp packet2\n");
printf("\n=> Packet Parse: TCP S2C Resp packet2\n");
packet_parse(&pkt, (const char *)tcp_pkt7_s2c_http_resp_2, sizeof(tcp_pkt7_s2c_http_resp_2));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 7) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -246,27 +261,23 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74 + 66 + 1354 + 385);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 7);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED | TCP_C2S_ACK_RECVED | TCP_S2C_ACK_RECVED | TCP_C2S_DATA_RECVED | TCP_S2C_DATA_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
__session_dispatch(sess);
__session_manager_check_counter(mgr, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// C2S ACK Packet
printf("=> packet parse: TCP C2S ACK packet\n");
printf("\n=> Packet Parse: TCP C2S ACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt8_c2s_ack, sizeof(tcp_pkt8_c2s_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 8) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -281,34 +292,30 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74 + 66 + 1354 + 385);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 8);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED | TCP_C2S_ACK_RECVED | TCP_S2C_ACK_RECVED | TCP_C2S_DATA_RECVED | TCP_S2C_DATA_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
__session_dispatch(sess);
__session_manager_check_counter(mgr, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// C2S FIN Packet
printf("=> packet parse: TCP C2S FIN packet\n");
printf("\n=> Packet Parse: TCP C2S FIN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt9_c2s_fin, sizeof(tcp_pkt9_c2s_fin));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 9) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_ACTIVE);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSING);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
@@ -316,27 +323,23 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74 + 66 + 1354 + 385);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 9);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED | TCP_C2S_ACK_RECVED | TCP_S2C_ACK_RECVED | TCP_C2S_DATA_RECVED | TCP_S2C_DATA_RECVED | TCP_C2S_FIN_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
__session_dispatch(sess);
__session_manager_check_counter(mgr, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// S2C FIN Packet
printf("=> packet parse: TCP S2C FIN packet\n");
printf("\n=> Packet Parse: TCP S2C FIN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt10_s2c_fin, sizeof(tcp_pkt10_s2c_fin));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 10) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -351,27 +354,23 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74 + 66 + 1354 + 385 + 66);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 10);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED | TCP_C2S_ACK_RECVED | TCP_S2C_ACK_RECVED | TCP_C2S_DATA_RECVED | TCP_S2C_DATA_RECVED | TCP_C2S_FIN_RECVED | TCP_S2C_FIN_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
__session_dispatch(sess);
__session_manager_check_counter(mgr, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// C2S ACK Packet
printf("=> packet parse: TCP C2S ACK packet\n");
printf("\n=> Packet Parse: TCP C2S ACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt11_c2s_ack, sizeof(tcp_pkt11_c2s_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 11) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -386,19 +385,39 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74 + 66 + 1354 + 385 + 66);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 11);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED | TCP_C2S_ACK_RECVED | TCP_S2C_ACK_RECVED | TCP_C2S_DATA_RECVED | TCP_S2C_DATA_RECVED | TCP_C2S_FIN_RECVED | TCP_S2C_FIN_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
__session_manager_check_counter(mgr, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_CLIENT_FIN);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
sess = session_manager_get_expired_session(mgr, 11 + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}

219
src/session/test/gtest_state_tcp_opening_to_active.cpp
View File

@@ -1,6 +1,43 @@
// TCP state machine test: opening -> active
#include <gtest/gtest.h>
#include "test_utils.h"
#include "session.h"
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_timeout_init = 1,
.tcp_timeout_handshake = 2,
.tcp_timeout_data = 3,
.tcp_timeout_half_closed = 4,
.tcp_timeout_time_wait = 5,
.tcp_timeout_discard = 6,
// udp timeout
.udp_timeout_data = 7,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_error_rate = 0.0001,
};
/******************************************************************************
* case: TCP opening -> active (by C2S DATA)
@@ -13,53 +50,32 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
printf("=> packet parse: TCP C2S SYN packet\n");
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_c2s_bytes(sess) == 78);
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYN_RECVED);
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
__session_dispatch(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// C2S DATA Packet
printf("=> packet parse: TCP C2S DATA packet\n");
printf("\n=> Packet Parse: TCP C2S DATA packet\n");
packet_parse(&pkt, (const char *)tcp_pkt4_c2s_http_req, sizeof(tcp_pkt4_c2s_http_req));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
@@ -73,19 +89,41 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 2);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_C2S_ACK_RECVED | TCP_C2S_DATA_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
__session_manager_check_counter(mgr, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_data) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_data + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -102,53 +140,32 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// SYNACK Packet
printf("=> packet parse: TCP S2C SYNACK packet\n");
// S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "93.184.216.34:80 -> 192.168.38.105:60111, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_c2s_bytes(sess) == 0);
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
EXPECT_TRUE(session_get_c2s_packets(sess) == 0);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYNACK_RECVED);
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_s2c_1st_pkt(sess));
__session_dispatch(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// S2C DATA Packet
printf("=> packet parse: TCP S2C DATA packet\n");
printf("\n=> Packet Parse: TCP S2C DATA packet\n");
packet_parse(&pkt, (const char *)tcp_pkt6_s2c_http_resq_1, sizeof(tcp_pkt6_s2c_http_resq_1));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
@@ -162,19 +179,41 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74 + 1354);
EXPECT_TRUE(session_get_c2s_packets(sess) == 0);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1 + 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 2);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYNACK_RECVED | TCP_S2C_ACK_RECVED | TCP_S2C_DATA_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
__session_manager_check_counter(mgr, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_data) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_data + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}

627
src/session/test/gtest_state_tcp_opening_to_closing.cpp
View File

@@ -1,47 +1,44 @@
// TCP state machine test: opening -> closing
#include <gtest/gtest.h>
#include "test_utils.h"
#include "session.h"
#include "session_manager.h"
static void build_opening_tcp_session(struct session_manager *mgr, struct session *sess)
{
char buffer[1024] = {0};
struct packet pkt;
#include "tcp_utils.h"
#include "test_packets.h"
// C2S SYN Packet
printf("=> packet parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess);
struct session_manager_options opts = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_c2s_bytes(sess) == 78);
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYN_RECVED);
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
__session_dispatch(sess);
// tcp timeout
.tcp_timeout_init = 1,
.tcp_timeout_handshake = 2,
.tcp_timeout_data = 3,
.tcp_timeout_half_closed = 4,
.tcp_timeout_time_wait = 5,
.tcp_timeout_discard = 6,
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// udp timeout
.udp_timeout_data = 7,
sleep(1);
timestamp_update();
}
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_error_rate = 0.0001,
};
/******************************************************************************
* case: TCP opening -> closing (by FIN-FIN)
@@ -54,55 +51,43 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
build_opening_tcp_session(mgr, sess);
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
// C2S FIN Packet
printf("=> packet parse: TCP C2S FIN packet\n");
printf("\n=> Packet Parse: TCP C2S FIN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt9_c2s_fin, sizeof(tcp_pkt9_c2s_fin));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
EXPECT_TRUE(session_get_c2s_bytes(sess) == 78 + 66);
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_C2S_ACK_RECVED | TCP_C2S_FIN_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
__session_dispatch(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
// S2C FIN Packet
printf("=> packet parse: TCP S2C FIN packet\n");
printf("\n=> Packet Parse: TCP S2C FIN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt10_s2c_fin, sizeof(tcp_pkt10_s2c_fin));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
@@ -116,19 +101,40 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 66);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 3);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_C2S_ACK_RECVED | TCP_S2C_ACK_RECVED | TCP_C2S_FIN_RECVED | TCP_S2C_FIN_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
__session_manager_check_counter(mgr, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_CLIENT_FIN);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -145,17 +151,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
build_opening_tcp_session(mgr, sess);
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
// C2S RST Packet
printf("=> packet parse: TCP C2S RST packet\n");
printf("\n=> Packet Parse: TCP C2S RST packet\n");
char tcp_pkt_c2s_rst[1500] = {0};
memcpy(tcp_pkt_c2s_rst, tcp_pkt9_c2s_fin, sizeof(tcp_pkt9_c2s_fin));
packet_parse(&pkt, (const char *)tcp_pkt_c2s_rst, sizeof(tcp_pkt9_c2s_fin));
@@ -164,9 +177,13 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr;
tcp_hdr_set_flags(hdr, 0);
tcp_hdr_set_rst_flag(hdr, true);
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
@@ -180,19 +197,40 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 2);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_C2S_RST_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
__session_manager_check_counter(mgr, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_CLIENT_RST);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -209,17 +247,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
build_opening_tcp_session(mgr, sess);
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
// S2C RST Packet
printf("=> packet parse: TCP S2C RST packet\n");
printf("\n=> Packet Parse: TCP S2C RST packet\n");
char tcp_pkt_s2c_rst[1500] = {0};
memcpy(tcp_pkt_s2c_rst, tcp_pkt10_s2c_fin, sizeof(tcp_pkt10_s2c_fin));
packet_parse(&pkt, (const char *)tcp_pkt_s2c_rst, sizeof(tcp_pkt10_s2c_fin));
@@ -228,9 +273,13 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr;
tcp_hdr_set_flags(hdr, 0);
tcp_hdr_set_rst_flag(hdr, true);
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
@@ -244,19 +293,40 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 66);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 2);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_S2C_RST_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
__session_manager_check_counter(mgr, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_SERVER_RST);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -269,20 +339,52 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
#if 1
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;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
build_opening_tcp_session(mgr, sess);
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= Packet Parse: done\n\n");
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_timeout_init) == NULL);
sess = session_manager_get_expired_session(mgr, 1 + opts.tcp_timeout_init + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -299,21 +401,32 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
build_opening_tcp_session(mgr, sess);
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
// S2C SYNACK Packet
printf("=> packet parse: TCP S2C SYNACK packet\n");
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
@@ -327,20 +440,41 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 2);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_handshake) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_handshake + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -357,56 +491,43 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
build_opening_tcp_session(mgr, sess);
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
// S2C SYNACK Packet
printf("=> packet parse: TCP S2C SYNACK packet\n");
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_c2s_bytes(sess) == 78);
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
__session_dispatch(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// ACK Packet
printf("=> packet parse: TCP C2S ACK packet\n");
// C2S ACK Packet
printf("\n=> Packet Parse: TCP C2S ACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt3_c2s_ack, sizeof(tcp_pkt3_c2s_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
@@ -420,56 +541,89 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 3);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED | TCP_C2S_ACK_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + opts.tcp_timeout_data) == NULL);
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_timeout_data + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
#endif
/******************************************************************************
* case: TCP opening -> closing (by C2S half closed timeout)
* case: TCP opening -> closing (by C2S half FIN)
******************************************************************************/
#if 1
TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
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;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
build_opening_tcp_session(mgr, sess);
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
// C2S FIN Packet
printf("=> packet parse: TCP C2S FIN packet\n");
printf("\n=> Packet Parse: TCP C2S FIN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt9_c2s_fin, sizeof(tcp_pkt9_c2s_fin));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSING);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
@@ -477,56 +631,88 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 2);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_C2S_ACK_RECVED | TCP_C2S_FIN_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_CLIENT_FIN);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
#endif
/******************************************************************************
* case: TCP opening -> closing (by S2C half closed timeout)
* case: TCP opening -> closing (by S2C half FIN)
******************************************************************************/
#if 1
TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
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;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
build_opening_tcp_session(mgr, sess);
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
// S2C FIN Packet
printf("=> packet parse: TCP S2C FIN packet\n");
printf("\n=> Packet Parse: TCP S2C FIN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt10_s2c_fin, sizeof(tcp_pkt10_s2c_fin));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSING);
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_get_dup_traffic_flag(sess) == DUP_TRAFFIC_NO);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
@@ -534,19 +720,40 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 66);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 2);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_S2C_ACK_RECVED | TCP_S2C_FIN_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_SERVER_FIN);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}

119
src/session/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
View File

@@ -1,14 +1,43 @@
// UDP state machine test: init -> opening -> active -> closing
#include <gtest/gtest.h>
#include "test_utils.h"
#include "session.h"
#include "session_manager.h"
/******************************************************************************
* case: UDP init -> opening (by C2S Packet)
*
* case UDP opening -> active (by S2C Packet)
*
* case UDP active -> closing (by timeout)
******************************************************************************/
#include "test_packets.h"
struct session_manager_options opts = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_timeout_init = 1,
.tcp_timeout_handshake = 2,
.tcp_timeout_data = 3,
.tcp_timeout_half_closed = 4,
.tcp_timeout_time_wait = 5,
.tcp_timeout_discard = 6,
// udp timeout
.udp_timeout_data = 7,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_error_rate = 0.0001,
};
#if 1
TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
@@ -17,17 +46,20 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S REQ Packet
printf("=> packet parse: UDP C2S REQ packet\n");
printf("\n=> Packet Parse: UDP C2S REQ packet\n");
packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
@@ -42,28 +74,23 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 1);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_udp_state(sess) == UDP_C2S_RECVED);
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
__session_dispatch(sess);
__session_manager_check_counter(mgr, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0);
sleep(1);
timestamp_update();
// S2C RESP Packet
printf("=> packet parse: UDP S2C RESP packet\n");
printf("\n=> Packet Parse: UDP S2C RESP packet\n");
packet_parse(&pkt, (const char *)udp_pkt2_dns_resp, sizeof(udp_pkt2_dns_resp));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get0_key(sess), buffer, sizeof(buffer));
@@ -77,19 +104,41 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 550);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) < timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 2);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_udp_state(sess) == (UDP_C2S_RECVED | UDP_S2C_RECVED));
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 1);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.udp_timeout_data) == NULL); // active -> closing
sess = session_manager_get_expired_session(mgr, 2 + opts.udp_timeout_data + opts.udp_timeout_data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}

148
src/session/test/gtest_state_udp_init_to_opening_to_closing.cpp
View File

@@ -1,10 +1,46 @@
// UDP state machine test: init -> opening
// UDP state machine test: init -> opening -> closing
#include <gtest/gtest.h>
#include "test_utils.h"
#include "session.h"
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_timeout_init = 1,
.tcp_timeout_handshake = 2,
.tcp_timeout_data = 3,
.tcp_timeout_half_closed = 4,
.tcp_timeout_time_wait = 5,
.tcp_timeout_discard = 6,
// udp timeout
.udp_timeout_data = 7,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_error_rate = 0.0001,
};
/******************************************************************************
* case: UDP init -> opening (by C2S Packet)
*
* case: UDP opening -> closing (by timeout)
* ******************************************************************************/
@@ -15,17 +51,20 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S REQ Packet
printf("=> packet parse: UDP C2S REQ packet\n");
printf("\n=> Packet Parse: UDP C2S REQ packet\n");
packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
@@ -40,20 +79,41 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
EXPECT_TRUE(session_get_new_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 1);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_udp_state(sess) == UDP_C2S_RECVED);
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
__session_manager_check_counter(mgr, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.udp_timeout_data) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + opts.udp_timeout_data + opts.udp_timeout_data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}
@@ -61,7 +121,6 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
/******************************************************************************
* case: UDP init -> opening (by S2C Packet)
*
* case: UDP opening -> closing (by timeout)
******************************************************************************/
@@ -72,17 +131,20 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// S2C RESP Packet
printf("=> packet parse: UDP S2C RESP packet\n");
printf("\n=> Packet Parse: UDP S2C RESP packet\n");
packet_parse(&pkt, (const char *)udp_pkt2_dns_resp, sizeof(udp_pkt2_dns_resp));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
@@ -97,20 +159,44 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
EXPECT_TRUE(session_get_s2c_bytes(sess) == 550);
EXPECT_TRUE(session_get_c2s_packets(sess) == 0);
EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
EXPECT_TRUE(session_get_new_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_sec());
EXPECT_TRUE(session_get_new_time(sess) == 1);
EXPECT_TRUE(session_get_last_time(sess) == 1);
EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_udp_state(sess) == UDP_S2C_RECVED);
EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) == NULL);
EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_s2c_1st_pkt(sess));
session_dump(sess);
__session_dispatch(sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
__session_manager_check_counter(mgr, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0);
__session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.udp_timeout_data) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + opts.udp_timeout_data + opts.udp_timeout_data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
// check stat
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
session_manager_free(mgr);
}

79
src/session/test/gtest_timeout_tcp_data.cpp
View File

@@ -1,4 +1,42 @@
#include "test_utils.h"
#include <gtest/gtest.h>
#include "session.h"
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_timeout_init = 1,
.tcp_timeout_handshake = 2,
.tcp_timeout_data = 3,
.tcp_timeout_half_closed = 4,
.tcp_timeout_time_wait = 5,
.tcp_timeout_discard = 6,
// udp timeout
.udp_timeout_data = 7,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_error_rate = 0.0001,
};
#if 1
TEST(TIMEOUT, TCP_TIMEOUT_DATA)
@@ -7,31 +45,40 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
printf("=> packet parse: TCP C2S SYN packet\n");
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
// C2S DATA Packet
printf("=> packet parse: TCP C2S DATA packet\n");
printf("\n=> Packet Parse: TCP C2S DATA packet\n");
packet_parse(&pkt, (const char *)tcp_pkt4_c2s_http_req, sizeof(tcp_pkt4_c2s_http_req));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
__session_manager_check_counter(mgr, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_check_tcp_timeout_data(mgr, &opts);
__session_manager_check_tcp_timeout_time_wait(mgr, &opts);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_data) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_timeout_data + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
session_manager_free(mgr);
}

88
src/session/test/gtest_timeout_tcp_half_closed.cpp
View File

@@ -1,88 +0,0 @@
#include "test_utils.h"
#if 1
TEST(TIMEOUT, TCP_TIMEOUT_HALF_CLOSED1)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
printf("=> packet parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess);
// C2S FIN Packet
printf("=> packet parse: TCP C2S FIN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt9_c2s_fin, sizeof(tcp_pkt9_c2s_fin));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_check_tcp_timeout_half_closed(mgr, &opts, SESSION_STATE_OPENING);
__session_manager_check_tcp_timeout_time_wait(mgr, &opts);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
session_manager_free(mgr);
}
#endif
#if 1
TEST(TIMEOUT, TCP_TIMEOUT_HALF_CLOSED2)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
printf("=> packet parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess);
// C2S DATA Packet
printf("=> packet parse: TCP C2S DATA packet\n");
packet_parse(&pkt, (const char *)tcp_pkt4_c2s_http_req, sizeof(tcp_pkt4_c2s_http_req));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess);
// C2S FIN Packet
printf("=> packet parse: TCP C2S FIN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt9_c2s_fin, sizeof(tcp_pkt9_c2s_fin));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
EXPECT_TRUE(sess);
__session_manager_check_counter(mgr, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_check_tcp_timeout_half_closed(mgr, &opts, SESSION_STATE_ACTIVE);
__session_manager_check_tcp_timeout_time_wait(mgr, &opts);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
session_manager_free(mgr);
}
#endif
int main(int argc, char **argv)
{
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

72
src/session/test/gtest_timeout_tcp_handshake.cpp
View File

@@ -1,4 +1,43 @@
#include "test_utils.h"
#include <gtest/gtest.h>
#include "session.h"
#include "session_manager.h"
#include "ipv4_utils.h"
#include "test_packets.h"
struct session_manager_options opts = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_timeout_init = 1,
.tcp_timeout_handshake = 2,
.tcp_timeout_data = 3,
.tcp_timeout_half_closed = 4,
.tcp_timeout_time_wait = 5,
.tcp_timeout_discard = 6,
// udp timeout
.udp_timeout_data = 7,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_error_rate = 0.0001,
};
#if 1
TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
@@ -7,24 +46,29 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// SYNACK Packet
printf("=> packet parse: TCP S2C SYNACK packet\n");
// S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_check_tcp_timeout_handshake(mgr, &opts);
__session_manager_check_tcp_timeout_time_wait(mgr, &opts);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_timeout_handshake) == NULL);
sess = session_manager_get_expired_session(mgr, 1 + opts.tcp_timeout_handshake + opts.tcp_timeout_time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
session_manager_free(mgr);
}

100
src/session/test/gtest_timeout_tcp_init.cpp
View File

@@ -1,60 +1,74 @@
#include "test_utils.h"
#include <gtest/gtest.h>
#include "session.h"
#include "session_manager.h"
#include "ipv4_utils.h"
#include "test_packets.h"
struct session_manager_options opts = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_timeout_init = 1,
.tcp_timeout_handshake = 2,
.tcp_timeout_data = 3,
.tcp_timeout_half_closed = 4,
.tcp_timeout_time_wait = 5,
.tcp_timeout_discard = 6,
// udp timeout
.udp_timeout_data = 7,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_error_rate = 0.0001,
};
#if 1
TEST(TIMEOUT, TCP_TIMEOUT_INIT1)
TEST(TIMEOUT, TCP_TIMEOUT_INIT)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S SYN Packet
printf("=> packet parse: TCP C2S SYN packet\n");
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_check_tcp_timeout_init(mgr, &opts);
__session_manager_check_tcp_timeout_time_wait(mgr, &opts);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
session_manager_free(mgr);
}
#endif
#if 1
TEST(TIMEOUT, TCP_TIMEOUT_INIT2)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
EXPECT_TRUE(mgr != NULL);
// S2C SYNACK Packet
printf("=> packet parse: TCP S2C SYNACK packet\n");
packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_timeout_init) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + opts.tcp_timeout_init + opts.tcp_timeout_time_wait); // closing -> closed
EXPECT_TRUE(sess);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
__session_manager_check_tcp_timeout_init(mgr, &opts);
__session_manager_check_tcp_timeout_time_wait(mgr, &opts);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
session_manager_free(mgr);
}

108
src/session/test/gtest_timeout_udp_data.cpp
View File

@@ -1,4 +1,42 @@
#include "test_utils.h"
#include <gtest/gtest.h>
#include "session.h"
#include "session_manager.h"
#include "test_packets.h"
struct session_manager_options opts = {
// max session number
.max_tcp_session_num = 256,
.max_udp_session_num = 256,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_timeout_init = 1,
.tcp_timeout_handshake = 2,
.tcp_timeout_data = 3,
.tcp_timeout_half_closed = 4,
.tcp_timeout_time_wait = 5,
.tcp_timeout_discard = 6,
// udp timeout
.udp_timeout_data = 7,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_error_rate = 0.0001,
};
#if 1
TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
@@ -7,24 +45,29 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S REQ Packet
printf("=> packet parse: UDP C2S REQ packet\n");
printf("\n=> Packet Parse: UDP C2S REQ packet\n");
packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
__session_manager_check_counter(mgr, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0);
__session_manager_check_udp_timeout_data(mgr, &opts, SESSION_STATE_OPENING);
EXPECT_TRUE(session_manager_get_expired_session(mgr) == NULL);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.udp_timeout_data) == NULL); // opening -> closing
sess = session_manager_get_expired_session(mgr, 1 + opts.udp_timeout_data + opts.udp_timeout_data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
session_manager_free(mgr);
}
@@ -37,31 +80,40 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
timestamp_update();
mgr = session_manager_new(&opts);
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
// C2S REQ Packet
printf("=> packet parse: UDP C2S REQ packet\n");
printf("\n=> Packet Parse: UDP C2S REQ packet\n");
packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
// new session
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
// S2C RESP Packet
printf("=> packet parse: UDP S2C RESP packet\n");
printf("\n=> Packet Parse: UDP S2C RESP packet\n");
packet_parse(&pkt, (const char *)udp_pkt2_dns_resp, sizeof(udp_pkt2_dns_resp));
printf("<= packet parse\n\n");
sess = session_manager_update_session(mgr, &pkt);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_lookup_session(mgr, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0);
__session_manager_check_udp_timeout_data(mgr, &opts, SESSION_STATE_ACTIVE);
EXPECT_TRUE(session_manager_get_expired_session(mgr) == NULL);
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.udp_timeout_data) == NULL); // active -> closing
sess = session_manager_get_expired_session(mgr, 2 + opts.udp_timeout_data + opts.udp_timeout_data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_dump(sess);
// free session
session_manager_free_session(mgr, sess);
session_manager_free(mgr);
}

353
src/session/test/test_utils.h
View File

@@ -1,353 +0,0 @@
#ifndef _TEST_STATE_MACHINE_H
#define _TEST_STATE_MACHINE_H
#ifdef __cpluscplus
extern "C"
{
#endif
#include <gtest/gtest.h>
#include "session_private.h"
#include "timestamp.h"
#include "session_manager.h"
#include "tcp_utils.h"
#include "ipv4_utils.h"
#include "test_packets.h"
struct session_manager_options opts = {
// max session number
.max_tcp_session_num = 3,
.max_udp_session_num = 3,
// session overload
.tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
.udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
// tcp timeout
.tcp_timeout_init = 2,
.tcp_timeout_handshake = 2,
.tcp_timeout_data = 2,
.tcp_timeout_half_closed = 2,
.tcp_timeout_time_wait = 2,
.tcp_timeout_discard = 2,
// udp timeout
.udp_timeout_data = 2,
// duplicate packet filter
.duplicated_packet_filter_enable = 1,
.duplicated_packet_filter_capacity = 1000,
.duplicated_packet_filter_timeout = 10,
.duplicated_packet_filter_error_rate = 0.0001,
// evicted session filter
.evicted_session_filter_enable = 1,
.evicted_session_filter_capacity = 1000,
.evicted_session_filter_timeout = 10,
.evicted_session_filter_error_rate = 0.0001,
};
__attribute__((unused)) static void __session_dispatch(struct session *sess)
{
if (sess == NULL)
{
return;
}
printf("\n");
printf("=> session dispatch: %p\n", sess);
session_dump(sess);
printf("<= session dispatch\n");
printf("\n");
session_set0_cur_pkt(sess, NULL);
session_set_cur_dir(sess, SESSION_DIR_NONE);
}
__attribute__((unused)) static void __session_manager_wait(struct session_manager *mgr, enum closing_reason reason)
{
struct session *sess;
for (int i = 0; i < 5; i++)
{
timestamp_update();
sess = session_manager_get_expired_session(mgr);
__session_dispatch(sess);
if (sess && session_get_state(sess) == SESSION_STATE_CLOSING)
{
EXPECT_TRUE(session_get_closing_reason(sess) == reason);
}
sess = session_manager_get_evicted_session(mgr);
__session_dispatch(sess);
if (sess && session_get_state(sess) == SESSION_STATE_CLOSING)
{
EXPECT_TRUE(session_get_closing_reason(sess) == reason);
}
sleep(1);
}
}
__attribute__((unused)) static void __session_manager_check_counter(struct session_manager *mgr,
uint64_t tcp_opening_sess_num, uint64_t tcp_active_sess_num, uint64_t tcp_closing_sess_num,
uint64_t udp_opening_sess_num, uint64_t udp_active_sess_num, uint64_t udp_closing_sess_num,
uint64_t tcp_overload_evict_new_sess_num, uint64_t tcp_overload_evict_old_sess_num,
uint64_t udp_overload_evict_new_sess_num, uint64_t udp_overload_evict_old_sess_num)
{
struct session_manager_stat *stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat->tcp_sess_num == tcp_opening_sess_num + tcp_active_sess_num + tcp_closing_sess_num);
EXPECT_TRUE(stat->tcp_opening_sess_num == tcp_opening_sess_num);
EXPECT_TRUE(stat->tcp_active_sess_num == tcp_active_sess_num);
EXPECT_TRUE(stat->tcp_closing_sess_num == tcp_closing_sess_num);
EXPECT_TRUE(stat->udp_sess_num == udp_opening_sess_num + udp_active_sess_num + udp_closing_sess_num);
EXPECT_TRUE(stat->udp_opening_sess_num == udp_opening_sess_num);
EXPECT_TRUE(stat->udp_active_sess_num == udp_active_sess_num);
EXPECT_TRUE(stat->udp_closing_sess_num == udp_closing_sess_num);
EXPECT_TRUE(stat->tcp_overload_evict_new_sess_num == tcp_overload_evict_new_sess_num);
EXPECT_TRUE(stat->tcp_overload_evict_old_sess_num == tcp_overload_evict_old_sess_num);
EXPECT_TRUE(stat->udp_overload_evict_new_sess_num == udp_overload_evict_new_sess_num);
EXPECT_TRUE(stat->udp_overload_evict_old_sess_num == udp_overload_evict_old_sess_num);
}
__attribute__((unused)) static void __session_manager_check_tcp_timeout_init(struct session_manager *mgr, struct session_manager_options *opts)
{
struct session *sess;
uint64_t interval;
uint64_t timeout_time = timestamp_get_sec() + opts->tcp_timeout_init;
printf("\n=> tcp_timeout_init\n");
for (uint64_t i = 0; i <= opts->tcp_timeout_init; i++)
{
timestamp_update();
sess = session_manager_get_expired_session(mgr);
interval = session_manager_get_expire_interval(mgr);
if (i == opts->tcp_timeout_init)
{
printf("timeout_time: %lu, curr_time: %lu, session expired\n",
timeout_time, timestamp_get_sec());
__session_manager_check_counter(mgr, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);
EXPECT_TRUE(sess != NULL);
break;
}
else
{
printf("timeout_time: %lu, curr_time: %lu, interval : %lu, session not expire\n",
timeout_time, timestamp_get_sec(), interval);
EXPECT_TRUE(interval <= opts->tcp_timeout_init);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
EXPECT_TRUE(sess == NULL);
}
sleep(1);
}
printf("<= tcp_timeout_init\n\n");
}
__attribute__((unused)) static void __session_manager_check_tcp_timeout_handshake(struct session_manager *mgr, struct session_manager_options *opts)
{
struct session *sess;
uint64_t interval;
uint64_t timeout_time = timestamp_get_sec() + opts->tcp_timeout_handshake;
printf("\n=> tcp_timeout_handshake\n");
for (uint64_t i = 0; i <= opts->tcp_timeout_handshake; i++)
{
timestamp_update();
sess = session_manager_get_expired_session(mgr);
interval = session_manager_get_expire_interval(mgr);
if (i == opts->tcp_timeout_handshake)
{
printf("timeout_time: %lu, curr_time: %lu, session expired\n",
timeout_time, timestamp_get_sec());
__session_manager_check_counter(mgr, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);
EXPECT_TRUE(sess != NULL);
break;
}
else
{
printf("timeout_time: %lu, curr_time: %lu, interval : %lu, session not expire\n",
timeout_time, timestamp_get_sec(), interval);
EXPECT_TRUE(interval <= opts->tcp_timeout_handshake);
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
EXPECT_TRUE(sess == NULL);
}
sleep(1);
}
printf("<= tcp_timeout_handshake\n\n");
}
__attribute__((unused)) static void __session_manager_check_tcp_timeout_data(struct session_manager *mgr, struct session_manager_options *opts)
{
struct session *sess;
uint64_t interval;
uint64_t timeout_time = timestamp_get_sec() + opts->tcp_timeout_data;
printf("\n=> tcp_timeout_data\n");
for (uint64_t i = 0; i <= opts->tcp_timeout_data; i++)
{
timestamp_update();
sess = session_manager_get_expired_session(mgr);
interval = session_manager_get_expire_interval(mgr);
if (i == opts->tcp_timeout_data)
{
printf("timeout_time: %lu, curr_time: %lu, session expired\n",
timeout_time, timestamp_get_sec());
__session_manager_check_counter(mgr, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);
EXPECT_TRUE(sess != NULL);
break;
}
else
{
printf("timeout_time: %lu, curr_time: %lu, interval : %lu, session not expire\n",
timeout_time, timestamp_get_sec(), interval);
EXPECT_TRUE(interval <= opts->tcp_timeout_data);
__session_manager_check_counter(mgr, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0);
EXPECT_TRUE(sess == NULL);
}
sleep(1);
}
printf("<= tcp_timeout_data\n\n");
}
__attribute__((unused)) static void __session_manager_check_tcp_timeout_half_closed(struct session_manager *mgr, struct session_manager_options *opts, enum session_state curr_state)
{
EXPECT_TRUE(curr_state == SESSION_STATE_OPENING || curr_state == SESSION_STATE_ACTIVE);
struct session *sess;
uint64_t interval;
uint64_t timeout_time = timestamp_get_sec() + opts->tcp_timeout_half_closed;
printf("\n=> tcp_timeout_half_closed\n");
for (uint64_t i = 0; i <= opts->tcp_timeout_half_closed; i++)
{
timestamp_update();
sess = session_manager_get_expired_session(mgr);
interval = session_manager_get_expire_interval(mgr);
if (i == opts->tcp_timeout_half_closed)
{
printf("timeout_time: %lu, curr_time: %lu, session expired\n",
timeout_time, timestamp_get_sec());
__session_manager_check_counter(mgr, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);
EXPECT_TRUE(sess != NULL);
break;
}
else
{
printf("timeout_time: %lu, curr_time: %lu, interval : %lu, session not expire\n",
timeout_time, timestamp_get_sec(), interval);
EXPECT_TRUE(interval <= opts->tcp_timeout_half_closed);
if (curr_state == SESSION_STATE_OPENING)
{
__session_manager_check_counter(mgr, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
}
if (curr_state == SESSION_STATE_ACTIVE)
{
__session_manager_check_counter(mgr, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0);
}
EXPECT_TRUE(sess == NULL);
}
sleep(1);
}
printf("<= tcp_timeout_half_closed\n\n");
}
__attribute__((unused)) static void __session_manager_check_tcp_timeout_time_wait(struct session_manager *mgr, struct session_manager_options *opts)
{
struct session *sess;
uint64_t interval;
uint64_t timeout_time = timestamp_get_sec() + opts->tcp_timeout_time_wait;
printf("\n=> tcp_timeout_time_wait\n");
for (uint64_t i = 0; i <= opts->tcp_timeout_time_wait; i++)
{
timestamp_update();
sess = session_manager_get_expired_session(mgr);
interval = session_manager_get_expire_interval(mgr);
if (i == opts->tcp_timeout_time_wait)
{
printf("timeout_time: %lu, curr_time: %lu, session expired\n",
timeout_time, timestamp_get_sec());
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
EXPECT_TRUE(sess == NULL);
break;
}
else
{
printf("timeout_time: %lu, curr_time: %lu, interval : %lu, session not expire\n",
timeout_time, timestamp_get_sec(), interval);
EXPECT_TRUE(interval <= opts->tcp_timeout_init);
__session_manager_check_counter(mgr, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);
EXPECT_TRUE(sess == NULL);
}
sleep(1);
}
printf("<= tcp_timeout_time_wait\n\n");
}
__attribute__((unused)) static void __session_manager_check_udp_timeout_data(struct session_manager *mgr, struct session_manager_options *opts, enum session_state curr_state)
{
EXPECT_TRUE(curr_state == SESSION_STATE_OPENING || curr_state == SESSION_STATE_ACTIVE);
struct session *sess;
uint64_t interval;
uint64_t timeout_time = timestamp_get_sec() + opts->udp_timeout_data;
printf("\n=> udp_timeout_data\n");
for (uint64_t i = 0; i <= opts->udp_timeout_data; i++)
{
timestamp_update();
sess = session_manager_get_expired_session(mgr);
interval = session_manager_get_expire_interval(mgr);
if (i == opts->udp_timeout_data)
{
printf("timeout_time: %lu, curr_time: %lu, session expired\n",
timeout_time, timestamp_get_sec());
__session_manager_check_counter(mgr, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0);
EXPECT_TRUE(sess != NULL);
break;
}
else
{
printf("timeout_time: %lu, curr_time: %lu, interval : %lu, session not expire\n",
timeout_time, timestamp_get_sec(), interval);
EXPECT_TRUE(interval <= opts->udp_timeout_data);
if (curr_state == SESSION_STATE_OPENING)
{
__session_manager_check_counter(mgr, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0);
}
if (curr_state == SESSION_STATE_ACTIVE)
{
__session_manager_check_counter(mgr, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0);
}
EXPECT_TRUE(sess == NULL);
}
sleep(1);
}
printf("<= udp_timeout_data\n\n");
}
#ifdef __cpluscplus
}
#endif
#endif