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

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