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

session manager support output fieldstat

Browse Source
This commit is contained in:
luwenpeng
2024-10-30 17:00:20 +08:00
parent 03864c9731
commit d56cda3d9a
46 changed files with 3208 additions and 3141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,68 +0,0 @@
#pragma once
#ifdef __cplusplus
extern "C"
{
#endif
#include "session_manager_runtime.h"
static struct session_manager_config sess_mgr_cfg = {
.instance_id = 1,
.thread_num = 1,
.session_id_seed = 0xFFFFF,
.tcp_session_max = 256,
.udp_session_max = 256,
.evict_old_on_tcp_table_limit = 1,
.evict_old_on_udp_table_limit = 1,
.expire_period_ms = 0,
.expire_batch_max = 1024,
.tcp_timeout_ms =
{
.init = 1,
.handshake = 2,
.data = 3,
.half_closed = 4,
.time_wait = 5,
.discard_default = 6,
.unverified_rst = 7,
},
.udp_timeout_ms =
{
.data = 8,
.discard_default = 0,
},
.duplicated_packet_bloom_filter =
{
.enable = 1,
.capacity = 1000,
.time_window_ms = 10,
.error_rate = 0.0001,
},
.evicted_session_bloom_filter =
{
.enable = 1,
.capacity = 1000,
.time_window_ms = 10,
.error_rate = 0.0001,
},
.tcp_reassembly =
{
.enable = 1,
.timeout_ms = 1000,
.buffered_segments_max = 16,
},
};
#ifdef __cplusplus
}
#endif

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

@@ -1,10 +1,4 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "packet_internal.h"
#include "packet_parser.h"
#include "session_internal.h"
#include "default_config.h"
#include "test_utils.h"
/******************************************************************************
* case: TCP init -> opening (by TCP Fast Open)
@@ -263,11 +257,11 @@ TEST(CASE, TCP_FAST_OPEN)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S fast open packet\n");
@@ -276,9 +270,10 @@ TEST(CASE, TCP_FAST_OPEN)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
@@ -347,7 +342,7 @@ TEST(CASE, TCP_FAST_OPEN)
session_free_tcp_segment(sess, seg);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -355,24 +350,25 @@ TEST(CASE, TCP_FAST_OPEN)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); // opening -> closing
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); // opening -> closing
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif

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

@@ -1,29 +1,15 @@
#include <gtest/gtest.h>
#include "packet_internal.h"
#include "packet_parser.h"
#include "session_internal.h"
#include "default_config.h"
#include "test_packets.h"
static void packet_set_ip_id(struct packet *pkt, uint16_t ip_id)
{
const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4);
EXPECT_TRUE(ipv4_layer);
struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
hdr->ip_id = htons(ip_id);
}
#include "test_utils.h"
#if 1
TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -32,12 +18,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
// check stat
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
@@ -48,12 +37,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == -1);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == -1);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
// check stat
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
@@ -63,20 +55,23 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
memset(&pkt, 0, sizeof(pkt));
packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
packet_set_ip_id(&pkt, 0x1234);
packet_overwrite_ipid(&pkt, 0x1234);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
// check stat
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -85,11 +80,11 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -98,12 +93,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
// check stat
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
@@ -114,12 +112,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == -1);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == -1);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
// check stat
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
@@ -129,20 +130,23 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
memcpy(synack_retransmission, tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
memset(&pkt, 0, sizeof(pkt));
packet_parse(&pkt, (const char *)synack_retransmission, sizeof(tcp_pkt2_s2c_syn_ack));
packet_set_ip_id(&pkt, 0x1234);
packet_overwrite_ipid(&pkt, 0x1234);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
// check stat
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -151,12 +155,12 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
char syn_retransmission[1500] = {0};
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -165,12 +169,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
// check stat
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
@@ -179,16 +186,19 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
memset(&pkt, 0, sizeof(pkt));
packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
packet_set_ip_id(&pkt, 0x1234);
packet_overwrite_ipid(&pkt, 0x1234);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
// check stat
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
@@ -197,16 +207,19 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
memset(&pkt, 0, sizeof(pkt));
packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
packet_set_ip_id(&pkt, 0x1235);
packet_overwrite_ipid(&pkt, 0x1235);
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
// check stat
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
@@ -217,16 +230,19 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
// check stat
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -235,14 +251,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
struct session_manager_config _cfg;
memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
_cfg.duplicated_packet_bloom_filter.enable = 0;
struct session_manager_cfg _sess_mgr_cfg;
memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg));
_sess_mgr_cfg.duplicated_packet_bloom_filter.enable = 0;
sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -251,12 +267,15 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
// check stat
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
@@ -267,16 +286,19 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
// check stat
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -285,14 +307,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
struct session_manager_config _cfg;
memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
_cfg.duplicated_packet_bloom_filter.enable = 0;
struct session_manager_cfg _sess_mgr_cfg;
memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg));
_sess_mgr_cfg.duplicated_packet_bloom_filter.enable = 0;
sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -301,12 +323,15 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
// check stat
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
@@ -317,16 +342,19 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
// check stat
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif

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

@@ -1,33 +1,18 @@
#include <gtest/gtest.h>
#include "utils_internal.h"
#include "packet_internal.h"
#include "packet_parser.h"
#include "session_internal.h"
#include "default_config.h"
#include "test_packets.h"
static void packet_set_ip_src_addr(struct packet *pkt, uint32_t addr)
{
const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4);
EXPECT_TRUE(ipv4_layer);
struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
hdr->ip_src.s_addr = htonl(addr);
}
#include "test_utils.h"
#if 1
TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
{
struct packet pkt;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
struct session_manager_config _cfg;
memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
_cfg.tcp_session_max = RX_BURST_MAX * 2;
_cfg.udp_session_max = RX_BURST_MAX * 2;
struct session_manager_cfg _sess_mgr_cfg;
memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg));
_sess_mgr_cfg.tcp_session_max = RX_BURST_MAX * 2;
_sess_mgr_cfg.udp_session_max = RX_BURST_MAX * 2;
sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -36,15 +21,15 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
printf("<= Packet Parse: done\n\n");
// new session
for (uint32_t i = 0; i < _cfg.tcp_session_max; i++)
for (uint32_t i = 0; i < _sess_mgr_cfg.tcp_session_max; i++)
{
packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i);
EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1));
}
printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
printf("=> Session Manager: after add %lu new sessions\n", _sess_mgr_cfg.tcp_session_max);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _cfg.tcp_session_max);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _sess_mgr_cfg.tcp_session_max);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
@@ -53,7 +38,7 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_table_full == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_session_not_found == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -61,16 +46,16 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
{
struct packet pkt;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
struct session_manager_config _cfg;
memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
_cfg.tcp_session_max = RX_BURST_MAX * 2;
_cfg.udp_session_max = RX_BURST_MAX * 2;
_cfg.evict_old_on_tcp_table_limit = 0;
struct session_manager_cfg _sess_mgr_cfg;
memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg));
_sess_mgr_cfg.tcp_session_max = RX_BURST_MAX * 2;
_sess_mgr_cfg.udp_session_max = RX_BURST_MAX * 2;
_sess_mgr_cfg.evict_old_on_tcp_table_limit = 0;
sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -79,16 +64,16 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
printf("<= Packet Parse: done\n\n");
// new session
for (uint32_t i = 0; i < _cfg.tcp_session_max; i++)
for (uint32_t i = 0; i < _sess_mgr_cfg.tcp_session_max; i++)
{
packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i);
EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1));
}
printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
printf("=> Session Manager: after add %lu new sessions\n", _sess_mgr_cfg.tcp_session_max);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _cfg.tcp_session_max);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _cfg.tcp_session_max);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _sess_mgr_cfg.tcp_session_max);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _sess_mgr_cfg.tcp_session_max);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closed == 0);
@@ -99,15 +84,16 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
// table full, evict new session
for (uint32_t i = 0; i < RX_BURST_MAX; i++)
{
packet_set_ip_src_addr(&pkt, _cfg.tcp_session_max + i);
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1) == NULL);
uint32_t idx = _sess_mgr_cfg.tcp_session_max + i;
packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&idx);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1) == NULL);
}
printf("=> Session Manager: after evicte new session\n");
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _cfg.tcp_session_max);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _cfg.tcp_session_max);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _sess_mgr_cfg.tcp_session_max);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _sess_mgr_cfg.tcp_session_max);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closed == 0);
@@ -115,7 +101,7 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_table_full == RX_BURST_MAX);
EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_session_not_found == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif

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

@@ -1,34 +1,19 @@
#include <gtest/gtest.h>
#include "utils_internal.h"
#include "packet_internal.h"
#include "packet_parser.h"
#include "session_internal.h"
#include "default_config.h"
#include "test_packets.h"
static void packet_set_ip_src_addr(struct packet *pkt, uint32_t addr)
{
const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4);
EXPECT_TRUE(ipv4_layer);
struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
hdr->ip_src.s_addr = htonl(addr);
}
#include "test_utils.h"
#if 1
TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
struct session_manager_config _cfg;
memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
_cfg.tcp_session_max = RX_BURST_MAX * 2;
_cfg.udp_session_max = RX_BURST_MAX * 2;
struct session_manager_cfg _sess_mgr_cfg;
memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg));
_sess_mgr_cfg.tcp_session_max = RX_BURST_MAX * 2;
_sess_mgr_cfg.udp_session_max = RX_BURST_MAX * 2;
sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S REQ Packet
printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -37,15 +22,15 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
printf("<= Packet Parse: done\n\n");
// new session
for (uint32_t i = 0; i < _cfg.udp_session_max; i++)
for (uint32_t i = 0; i < _sess_mgr_cfg.udp_session_max; i++)
{
packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i);
EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1));
}
printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
printf("=> Session Manager: after add %lu new sessions\n", _sess_mgr_cfg.udp_session_max);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _cfg.udp_session_max);
EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _sess_mgr_cfg.udp_session_max);
EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
@@ -57,10 +42,10 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
// evicted session
while (1)
{
sess = session_manager_runtime_get_evicted_session(sess_mgr_rt);
sess = session_manager_rte_get_evicted_session(sess_mgr_rte);
if (sess)
{
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
}
else
{
@@ -70,12 +55,12 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
for (uint32_t i = 0; i < RX_BURST_MAX; i++)
{
packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1) == NULL); // hit evicted session, can't renew session
packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1) == NULL); // hit evicted session, can't renew session
}
printf("=> Session Manager: after readd %d evicted sessions\n", RX_BURST_MAX);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->udp_sess_used == RX_BURST_MAX);
EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == RX_BURST_MAX);
@@ -87,11 +72,12 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX);
// evicted session timeout
packet_set_ip_src_addr(&pkt, 0);
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1 + _cfg.evicted_session_bloom_filter.time_window_ms));
uint32_t idx = 0;
packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&idx);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1 + _sess_mgr_cfg.evicted_session_bloom_filter.time_window_ms));
printf("=> Session Manager: after evicted session timeout\n");
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->udp_sess_used == RX_BURST_MAX + 1);
EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == RX_BURST_MAX);
@@ -102,7 +88,7 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == 0);
EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -110,16 +96,16 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
{
struct packet pkt;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
struct session_manager_config _cfg;
memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
_cfg.tcp_session_max = RX_BURST_MAX * 2;
_cfg.udp_session_max = RX_BURST_MAX * 2;
_cfg.evict_old_on_udp_table_limit = 0;
struct session_manager_cfg _sess_mgr_cfg;
memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg));
_sess_mgr_cfg.tcp_session_max = RX_BURST_MAX * 2;
_sess_mgr_cfg.udp_session_max = RX_BURST_MAX * 2;
_sess_mgr_cfg.evict_old_on_udp_table_limit = 0;
sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S REQ Packet
printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -128,16 +114,16 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
printf("<= Packet Parse: done\n\n");
// new session
for (uint32_t i = 0; i < _cfg.udp_session_max; i++)
for (uint32_t i = 0; i < _sess_mgr_cfg.udp_session_max; i++)
{
packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i);
EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1));
}
printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
printf("=> Session Manager: after add %lu new sessions\n", _sess_mgr_cfg.udp_session_max);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _cfg.udp_session_max);
EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _cfg.udp_session_max);
EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _sess_mgr_cfg.udp_session_max);
EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _sess_mgr_cfg.udp_session_max);
EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == 0);
@@ -146,20 +132,21 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == 0);
// evicted session
EXPECT_TRUE(session_manager_runtime_get_evicted_session(sess_mgr_rt) == NULL);
EXPECT_TRUE(session_manager_rte_get_evicted_session(sess_mgr_rte) == NULL);
// table full, evict new session
for (uint32_t i = 0; i < RX_BURST_MAX; i++)
{
packet_set_ip_src_addr(&pkt, _cfg.udp_session_max + i);
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1) == NULL);
uint32_t idx = _sess_mgr_cfg.udp_session_max + i;
packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&idx);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1) == NULL);
}
printf("=> Session Manager: after readd %d evicted session\n", RX_BURST_MAX);
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _cfg.udp_session_max);
EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _cfg.udp_session_max);
EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _sess_mgr_cfg.udp_session_max);
EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _sess_mgr_cfg.udp_session_max);
EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == 0);
@@ -167,7 +154,7 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == RX_BURST_MAX);
EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif

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

@@ -1,27 +1,13 @@
#include <gtest/gtest.h>
#include "test_utils.h"
#include "session_internal.h"
#include "packet_internal.h"
#include "packet_parser.h"
#include "default_config.h"
#include "test_packets.h"
static inline void packet_overwrite_src_addr(struct packet *pkt, struct in_addr addr)
static inline void mached_session_print(const char *title, struct session_manager_rte *sess_mgr_rte, uint64_t mached_sess_id[], uint64_t mached_sess_num)
{
const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4);
struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
hdr->ip_src = addr;
}
static inline void mached_session_print(const char *title, struct session_manager_runtime *sess_mgr_rt, uint64_t mached_sess_ids[], uint64_t mached_sess_num)
{
struct session *sess = NULL;
printf("%-*s mached_sess_num: %lu\n", 40, title, mached_sess_num);
for (uint64_t i = 0; i < mached_sess_num; i++)
{
sess = session_manager_runtime_lookup_session_by_id(sess_mgr_rt, mached_sess_ids[i]);
struct session *sess = session_manager_rte_lookup_session_by_id(sess_mgr_rte, mached_sess_id[i]);
printf("session id: %lu, addr: %s, type: %s, state: %s, start: %lu, last: %lu\n",
mached_sess_ids[i], session_get0_readable_addr(sess),
mached_sess_id[i], session_get0_readable_addr(sess),
session_type_to_str(session_get_type(sess)),
session_state_to_str(session_get_current_state(sess)),
session_get_timestamp(sess, SESSION_TIMESTAMP_START),
@@ -34,10 +20,10 @@ TEST(SESS_MGR_SCAN, OPTS)
{
char buff[1500] = {0};
uint64_t mached_sess_num = 0;
uint64_t mached_sess_ids[1460];
uint64_t mached_sess_id[1460];
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct in_addr v4_src_addr1 = {};
struct in_addr v4_src_addr2 = {};
@@ -85,91 +71,91 @@ TEST(SESS_MGR_SCAN, OPTS)
inet_pton(AF_INET6, "cafe::0000", &v6_dst_subnet_beg);
inet_pton(AF_INET6, "cafe::ffff", &v6_dst_subnet_end);
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// new session
memset(&pkt, 0, sizeof(pkt));
memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn));
packet_overwrite_src_addr(&pkt, v4_src_addr1);
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
packet_overwrite_v4_saddr(&pkt, &v4_src_addr1);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// new session
memset(&pkt, 0, sizeof(pkt));
memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn));
packet_overwrite_src_addr(&pkt, v4_src_addr2);
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 2);
packet_overwrite_v4_saddr(&pkt, &v4_src_addr2);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 2);
EXPECT_TRUE(sess);
// new session
memset(&pkt, 0, sizeof(pkt));
memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn));
packet_overwrite_src_addr(&pkt, v4_src_addr3);
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 3);
packet_overwrite_v4_saddr(&pkt, &v4_src_addr3);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 3);
EXPECT_TRUE(sess);
// new session
memset(&pkt, 0, sizeof(pkt));
packet_parse(&pkt, (const char *)ipv6_in_ipv6_udp, sizeof(ipv6_in_ipv6_udp));
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 4);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 4);
EXPECT_TRUE(sess);
struct session_scan_opts scan = {};
// scan.flags = SESSION_SCAN_TYPE | SESSION_SCAN_STATE | SESSION_SCAN_SIP | SESSION_SCAN_DIP | SESSION_SCAN_SPORT | SESSION_SCAN_DPORT | SESSION_SCAN_CREATE_TIME | SESSION_SCAN_LAST_PKT_TIME;
// scan.flags = SESSION_SCAN_TYPE | SESSION_SCAN_STATE | SESSION_SCAN_SIP | SESSION_SCAN_DIP | SESSION_SCAN_SPORT | SESSION_SCAN_DPORT | SESSION_SCAN_CREATE_TIME | SESSION_SCAN_LASPKT_TIME;
scan.cursor = 0;
scan.count = 1460;
scan.last_pkt_time_ms[0] = 0;
scan.last_pkt_time_ms[1] = UINT64_MAX;
scan.laspkt_time_ms[0] = 0;
scan.laspkt_time_ms[1] = UINT64_MAX;
// SESSION_SCAN_TYPE
scan.flags = SESSION_SCAN_TYPE;
scan.type = SESSION_TYPE_TCP;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 3);
mached_session_print("SESSION_SCAN_TYPE: (TCP)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_TYPE: (TCP)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.type = SESSION_TYPE_UDP;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 1);
mached_session_print("SESSION_SCAN_TYPE: (UDP)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_TYPE: (UDP)", sess_mgr_rte, mached_sess_id, mached_sess_num);
// SESSION_SCAN_STATE
scan.flags = SESSION_SCAN_STATE;
scan.state = SESSION_STATE_OPENING;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 4);
mached_session_print("SESSION_SCAN_STATE: (OPENING)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_STATE: (OPENING)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.state = SESSION_STATE_ACTIVE;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_STATE: (ACTIVE)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_STATE: (ACTIVE)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.state = SESSION_STATE_CLOSING;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_STATE: (CLOSING)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_STATE: (CLOSING)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.state = SESSION_STATE_DISCARD;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_STATE: (DISCARD)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_STATE: (DISCARD)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.state = SESSION_STATE_CLOSED;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_STATE: (CLOSED)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_STATE: (CLOSED)", sess_mgr_rte, mached_sess_id, mached_sess_num);
// SESSION_SCAN_SIP
scan.flags = SESSION_SCAN_SIP;
@@ -177,44 +163,44 @@ TEST(SESS_MGR_SCAN, OPTS)
scan.addr_family = AF_INET;
scan.src_addr[0].v4 = v4_src_addr1;
scan.src_addr[1].v4 = v4_src_addr1;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 1);
mached_session_print("SESSION_SCAN_SIP: (IPv4)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_SIP: (IPv4)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.addr_family = AF_INET;
scan.src_addr[0].v4 = v4_src_subnet_beg;
scan.src_addr[1].v4 = v4_src_subnet_end;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 3);
mached_session_print("SESSION_SCAN_SIP: (IPv4 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_SIP: (IPv4 SUBNET)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.addr_family = AF_INET;
scan.src_addr[0].v4 = v4_min_addr;
scan.src_addr[1].v4 = v4_max_addr;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 3);
mached_session_print("SESSION_SCAN_SIP: (IPv4 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_SIP: (IPv4 MIN MAX)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.addr_family = AF_INET6;
memcpy(&scan.src_addr[0].v6, &v6_src_addr, sizeof(v6_src_addr));
memcpy(&scan.src_addr[1].v6, &v6_src_addr, sizeof(v6_src_addr));
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 1);
mached_session_print("SESSION_SCAN_SIP: (IPv6)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_SIP: (IPv6)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.addr_family = AF_INET6;
memcpy(&scan.src_addr[0].v6, &v6_src_subnet_beg, sizeof(v6_src_subnet_beg));
memcpy(&scan.src_addr[1].v6, &v6_src_subnet_end, sizeof(v6_src_subnet_end));
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 1);
mached_session_print("SESSION_SCAN_SIP: (IPv6 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_SIP: (IPv6 SUBNET)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.addr_family = AF_INET6;
memcpy(&scan.src_addr[0].v6, &v6_min_addr, sizeof(v6_min_addr));
memcpy(&scan.src_addr[1].v6, &v6_max_addr, sizeof(v6_max_addr));
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 1);
mached_session_print("SESSION_SCAN_SIP: (IPv6 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_SIP: (IPv6 MIN MAX)", sess_mgr_rte, mached_sess_id, mached_sess_num);
// SESSION_SCAN_DIP
scan.flags = SESSION_SCAN_DIP;
@@ -222,126 +208,126 @@ TEST(SESS_MGR_SCAN, OPTS)
scan.addr_family = AF_INET;
scan.dst_addr[0].v4 = v4_dst_addr;
scan.dst_addr[1].v4 = v4_dst_addr;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 3);
mached_session_print("SESSION_SCAN_DIP: (IPv4)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_DIP: (IPv4)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.addr_family = AF_INET;
scan.dst_addr[0].v4 = v4_dst_subnet_beg;
scan.dst_addr[1].v4 = v4_dst_subnet_end;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 3);
mached_session_print("SESSION_SCAN_DIP: (IPv4 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_DIP: (IPv4 SUBNET)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.addr_family = AF_INET;
scan.dst_addr[0].v4 = v4_min_addr;
scan.dst_addr[1].v4 = v4_max_addr;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 3);
mached_session_print("SESSION_SCAN_DIP: (IPv4 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_DIP: (IPv4 MIN MAX)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.addr_family = AF_INET6;
memcpy(&scan.dst_addr[0].v6, &v6_dst_addr, sizeof(v6_dst_addr));
memcpy(&scan.dst_addr[1].v6, &v6_dst_addr, sizeof(v6_dst_addr));
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 1);
mached_session_print("SESSION_SCAN_DIP: (IPv6)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_DIP: (IPv6)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.addr_family = AF_INET6;
memcpy(&scan.dst_addr[0].v6, &v6_dst_subnet_beg, sizeof(v6_dst_subnet_beg));
memcpy(&scan.dst_addr[1].v6, &v6_dst_subnet_end, sizeof(v6_dst_subnet_end));
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 1);
mached_session_print("SESSION_SCAN_DIP: (IPv6 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_DIP: (IPv6 SUBNET)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.addr_family = AF_INET6;
memcpy(&scan.dst_addr[0].v6, &v6_min_addr, sizeof(v6_min_addr));
memcpy(&scan.dst_addr[1].v6, &v6_max_addr, sizeof(v6_max_addr));
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 1);
mached_session_print("SESSION_SCAN_DIP: (IPv6 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_DIP: (IPv6 MIN MAX)", sess_mgr_rte, mached_sess_id, mached_sess_num);
// SESSION_SCAN_SPORT
scan.flags = SESSION_SCAN_SPORT;
scan.src_port = htons(60111);
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 3);
mached_session_print("SESSION_SCAN_SPORT: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_SPORT: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.src_port = htons(60110);
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_SPORT: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_SPORT: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num);
// SESSION_SCAN_DPORT
scan.flags = SESSION_SCAN_DPORT;
scan.dst_port = htons(80);
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 3);
mached_session_print("SESSION_SCAN_DPORT: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_DPORT: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.dst_port = htons(81);
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_DPORT: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_DPORT: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num);
// SESSION_SCAN_CREATE_TIME
scan.flags = SESSION_SCAN_CREATE_TIME;
scan.create_time_ms[0] = 0;
scan.create_time_ms[1] = UINT64_MAX;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 4);
mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.create_time_ms[0] = 1;
scan.create_time_ms[1] = 2;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 2);
mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.create_time_ms[0] = 0;
scan.create_time_ms[1] = 0;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.create_time_ms[0] = UINT64_MAX;
scan.create_time_ms[1] = UINT64_MAX;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num);
// SESSION_SCAN_LAST_PKT_TIME
scan.flags = SESSION_SCAN_LAST_PKT_TIME;
// SESSION_SCAN_LASPKT_TIME
scan.flags = SESSION_SCAN_LASPKT_TIME;
scan.last_pkt_time_ms[0] = 0;
scan.last_pkt_time_ms[1] = UINT64_MAX;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
scan.laspkt_time_ms[0] = 0;
scan.laspkt_time_ms[1] = UINT64_MAX;
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 4);
mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_LASPKT_TIME: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.last_pkt_time_ms[0] = 1;
scan.last_pkt_time_ms[1] = 2;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
scan.laspkt_time_ms[0] = 1;
scan.laspkt_time_ms[1] = 2;
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 2);
mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_LASPKT_TIME: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.last_pkt_time_ms[0] = 0;
scan.last_pkt_time_ms[1] = 0;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
scan.laspkt_time_ms[0] = 0;
scan.laspkt_time_ms[1] = 0;
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_LASPKT_TIME: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num);
scan.last_pkt_time_ms[0] = UINT64_MAX;
scan.last_pkt_time_ms[1] = UINT64_MAX;
mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
scan.laspkt_time_ms[0] = UINT64_MAX;
scan.laspkt_time_ms[1] = UINT64_MAX;
mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
mached_session_print("SESSION_SCAN_LASPKT_TIME: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif

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

@@ -1,24 +1,4 @@
#include <gtest/gtest.h>
#include "packet_internal.h"
#include "packet_parser.h"
#include "session_internal.h"
#include "default_config.h"
#include "test_packets.h"
static void hex_dump(const char *payload, uint32_t len)
{
printf("Payload Length: %u\n", len);
for (uint32_t i = 0; i < len; i++)
{
if (i > 0 && i % 16 == 0)
{
printf("\n");
}
printf("%02x ", (uint8_t)payload[i]);
}
printf("\n");
}
#include "test_utils.h"
#if 1
TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
@@ -26,10 +6,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
struct tcp_segment *seg;
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -38,9 +18,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
seg = session_get_tcp_segment(sess);
@@ -53,10 +34,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL);
@@ -68,10 +50,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL);
@@ -83,10 +66,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 4) == 0);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL);
@@ -98,10 +82,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 5) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 5) == 0);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL);
@@ -113,10 +98,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 6) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 6) == 0);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL);
@@ -128,10 +114,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 7) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 7) == 0);
/*
* 11111111111111111111111111111111111111111111111111111111111111
@@ -166,48 +153,49 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
EXPECT_TRUE(seg != NULL);
EXPECT_TRUE(seg->len == sizeof(payload1));
EXPECT_TRUE(memcmp((void *)seg->data, payload1, sizeof(payload1)) == 0);
hex_dump((const char *)seg->data, seg->len);
hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
session_free_tcp_segment(sess, seg);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg != NULL);
EXPECT_TRUE(seg->len == sizeof(payload2));
EXPECT_TRUE(memcmp((void *)seg->data, payload2, sizeof(payload2)) == 0);
hex_dump((const char *)seg->data, seg->len);
hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
session_free_tcp_segment(sess, seg);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg != NULL);
EXPECT_TRUE(seg->len == sizeof(payload3));
EXPECT_TRUE(memcmp((void *)seg->data, payload3, sizeof(payload3)) == 0);
hex_dump((const char *)seg->data, seg->len);
hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
session_free_tcp_segment(sess, seg);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg != NULL);
EXPECT_TRUE(seg->len == sizeof(payload4));
EXPECT_TRUE(memcmp((void *)seg->data, payload4, sizeof(payload4)) == 0);
hex_dump((const char *)seg->data, seg->len);
hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
session_free_tcp_segment(sess, seg);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg != NULL);
EXPECT_TRUE(seg->len == sizeof(payload5));
EXPECT_TRUE(memcmp((void *)seg->data, payload5, sizeof(payload5)) == 0);
hex_dump((const char *)seg->data, seg->len);
hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
session_free_tcp_segment(sess, seg);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 7 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); // active -> closing
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 7 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 7 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); // active -> closing
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 7 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_runtime_free(sess_mgr_rt);
// free session
session_manager_rte_free_session(sess_mgr_rte, sess);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -217,10 +205,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
struct tcp_segment *seg;
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -229,9 +217,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
seg = session_get_tcp_segment(sess);
@@ -244,10 +233,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL);
@@ -259,16 +249,17 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg != NULL);
EXPECT_TRUE(seg->len == sizeof(tcp_seq_wraparound_pkt3_payload));
EXPECT_TRUE(memcmp((void *)seg->data, tcp_seq_wraparound_pkt3_payload, sizeof(tcp_seq_wraparound_pkt3_payload)) == 0);
hex_dump((const char *)seg->data, seg->len);
hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
session_free_tcp_segment(sess, seg);
// C2S Data Packet
@@ -278,29 +269,31 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 4) == 0);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg != NULL);
EXPECT_TRUE(seg->len == sizeof(tcp_seq_wraparound_pkt4_payload));
EXPECT_TRUE(memcmp((void *)seg->data, tcp_seq_wraparound_pkt4_payload, sizeof(tcp_seq_wraparound_pkt4_payload)) == 0);
hex_dump((const char *)seg->data, seg->len);
hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
session_free_tcp_segment(sess, seg);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 4 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); // active -> closing
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 4 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 4 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); // active -> closing
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 4 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_runtime_free(sess_mgr_rt);
// free session
session_manager_rte_free_session(sess_mgr_rte, sess);
session_manager_rte_free(sess_mgr_rte);
}
#endif

5
infra/session_manager/test/gtest_session_filter.cpp
View File

@@ -1,7 +1,4 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "session_filter.h"
#include "test_utils.h"
TEST(SESSION_FILTER, TEST)
{

4
infra/session_manager/test/gtest_session_pool.cpp
View File

@@ -1,6 +1,4 @@
#include <gtest/gtest.h>
#include "session_pool.h"
#include "test_utils.h"
TEST(SESSION_POOL, POP_PUSH)
{

7
infra/session_manager/test/gtest_session_table.cpp
View File

@@ -1,9 +1,4 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "session_internal.h"
#include "session_pool.h"
#include "session_table.h"
#include "test_utils.h"
#define TUPLE6_SET_V4_TCP(t6) \
{ \

5
infra/session_manager/test/gtest_session_timer.cpp
View File

@@ -1,7 +1,4 @@
#include <gtest/gtest.h>
#include "session_internal.h"
#include "session_timer.h"
#include "test_utils.h"
TEST(SESSION_TIMER, EXPIRE)
{

4
infra/session_manager/test/gtest_session_transition.cpp
View File

@@ -1,6 +1,4 @@
#include <gtest/gtest.h>
#include "session_transition.h"
#include "test_utils.h"
TEST(SESSION_TRANSITION, RUN)
{

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

@@ -1,14 +1,7 @@
// TCP state machine test: active -> closing
#include <gtest/gtest.h>
#include "test_utils.h"
#include "tuple.h"
#include "packet_internal.h"
#include "packet_parser.h"
#include "session_internal.h"
#include "default_config.h"
#include "test_packets.h"
static void build_active_tcp_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess)
static void build_active_tcp_session(struct session_manager_rte *sess_mgr_rte, struct session *sess)
{
struct packet pkt;
@@ -19,9 +12,10 @@ static void build_active_tcp_session(struct session_manager_runtime *sess_mgr_rt
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// C2S DATA Packet
@@ -31,10 +25,11 @@ static void build_active_tcp_session(struct session_manager_runtime *sess_mgr_rt
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
}
/******************************************************************************
@@ -47,14 +42,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet & C2S DATA Packet
build_active_tcp_session(sess_mgr_rt, sess);
build_active_tcp_session(sess_mgr_rte, sess);
// C2S FIN Packet
printf("\n=> Packet Parse: TCP C2S FIN packet\n");
@@ -63,10 +58,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
// S2C FIN Packet
printf("\n=> Packet Parse: TCP S2C FIN packet\n");
@@ -75,10 +71,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -100,7 +97,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -108,23 +105,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -138,14 +136,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet & C2S DATA Packet
build_active_tcp_session(sess_mgr_rt, sess);
build_active_tcp_session(sess_mgr_rte, sess);
// C2S RST Packet
printf("\n=> Packet Parse: TCP C2S RST packet\n");
@@ -160,10 +158,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -185,7 +184,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -193,23 +192,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -223,14 +223,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet & C2S DATA Packet
build_active_tcp_session(sess_mgr_rt, sess);
build_active_tcp_session(sess_mgr_rte, sess);
// S2C RST Packet
printf("\n=> Packet Parse: TCP S2C RST packet\n");
@@ -245,10 +245,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -270,7 +271,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -278,23 +279,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -306,17 +308,17 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
{
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet & C2S DATA Packet
build_active_tcp_session(sess_mgr_rt, sess);
build_active_tcp_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -324,24 +326,25 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -355,14 +358,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet & C2S DATA Packet
build_active_tcp_session(sess_mgr_rt, sess);
build_active_tcp_session(sess_mgr_rte, sess);
// C2S FIN Packet
printf("\n=> Packet Parse: TCP C2S FIN packet\n");
@@ -371,10 +374,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -396,7 +400,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -404,23 +408,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -434,14 +439,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet & C2S DATA Packet
build_active_tcp_session(sess_mgr_rt, sess);
build_active_tcp_session(sess_mgr_rte, sess);
// S2C FIN Packet
printf("\n=> Packet Parse: TCP S2C FIN packet\n");
@@ -450,10 +455,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -475,7 +481,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -483,23 +489,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif

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

@@ -1,12 +1,5 @@
// TCP state machine test: init -> opening
#include <gtest/gtest.h>
#include "tuple.h"
#include "packet_internal.h"
#include "packet_parser.h"
#include "session_internal.h"
#include "default_config.h"
#include "test_packets.h"
#include "test_utils.h"
/******************************************************************************
* case: TCP init -> opening (by SYN)
@@ -18,11 +11,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -31,9 +24,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
@@ -56,7 +50,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -64,24 +58,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); // opening -> closing
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); // opening -> closing
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -95,11 +90,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -108,9 +103,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
@@ -133,7 +129,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -141,24 +137,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -172,11 +169,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -185,9 +182,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// S2C SYNACK Packet
@@ -197,10 +195,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -222,7 +221,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -230,24 +229,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -261,11 +261,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -274,9 +274,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// S2C SYNACK Packet
@@ -286,10 +287,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
// C2S ACK Packet
printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -298,10 +300,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -323,7 +326,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -331,24 +334,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -364,11 +368,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -377,9 +381,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// C2S SYN Packet retransmission
@@ -394,10 +399,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -419,7 +425,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -427,24 +433,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -460,11 +467,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -473,9 +480,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// SYNACK Packet retransmission
@@ -491,10 +499,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -516,7 +525,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -524,24 +533,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -555,11 +565,11 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -568,9 +578,10 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// C2S ACK Packet
@@ -580,10 +591,11 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -605,7 +617,7 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -613,24 +625,25 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -644,11 +657,11 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -657,9 +670,10 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// S2C ACK Packet
@@ -669,10 +683,11 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -694,7 +709,7 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -702,24 +717,25 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif

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

@@ -1,12 +1,5 @@
// TCP state machine test: init -> opening -> active -> closing -> closed
#include <gtest/gtest.h>
#include "tuple.h"
#include "packet_internal.h"
#include "packet_parser.h"
#include "session_internal.h"
#include "default_config.h"
#include "test_packets.h"
#include "test_utils.h"
#if 1
TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
@@ -14,11 +7,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
char buffer[1024];
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -27,9 +20,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
@@ -58,10 +52,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -89,10 +84,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -120,10 +116,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 4) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -151,10 +148,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 5) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 5) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -182,10 +180,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 6) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 6) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -213,10 +212,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 7) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 7) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -244,10 +244,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 8) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 8) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -275,10 +276,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 9) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 9) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -306,10 +308,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 10) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 10) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -337,10 +340,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 11) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 11) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer));
@@ -362,7 +366,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -370,23 +374,24 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 11 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 11 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif

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

@@ -1,12 +1,5 @@
// TCP state machine test: opening -> active
#include <gtest/gtest.h>
#include "tuple.h"
#include "packet_internal.h"
#include "packet_parser.h"
#include "session_internal.h"
#include "default_config.h"
#include "test_packets.h"
#include "test_utils.h"
/******************************************************************************
* case: TCP opening -> active (by C2S DATA)
@@ -18,11 +11,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -31,9 +24,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// C2S DATA Packet
@@ -43,10 +37,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -68,7 +63,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -76,24 +71,25 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -107,11 +103,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -120,9 +116,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// S2C DATA Packet
@@ -132,10 +129,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -157,7 +155,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -165,24 +163,25 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif

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

@@ -1,12 +1,5 @@
// TCP state machine test: opening -> closing
#include <gtest/gtest.h>
#include "tuple.h"
#include "packet_internal.h"
#include "packet_parser.h"
#include "session_internal.h"
#include "default_config.h"
#include "test_packets.h"
#include "test_utils.h"
/******************************************************************************
* case: TCP opening -> closing (by FIN-FIN)
@@ -18,11 +11,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -31,9 +24,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// C2S FIN Packet
@@ -43,10 +37,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
// S2C FIN Packet
printf("\n=> Packet Parse: TCP S2C FIN packet\n");
@@ -55,10 +50,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -80,7 +76,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -88,23 +84,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -118,11 +115,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -131,9 +128,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// C2S RST Packet
@@ -149,10 +147,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -174,7 +173,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -182,23 +181,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -212,11 +212,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -225,9 +225,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// S2C RST Packet
@@ -243,10 +244,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -268,7 +270,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -276,23 +278,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -305,11 +308,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -318,13 +321,14 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -332,24 +336,25 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -363,11 +368,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -376,9 +381,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// S2C SYNACK Packet
@@ -388,10 +394,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -413,7 +420,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -421,24 +428,25 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -452,11 +460,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -465,9 +473,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// S2C SYNACK Packet
@@ -477,10 +486,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
// C2S ACK Packet
printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -489,10 +499,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -514,7 +525,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -522,24 +533,25 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -553,11 +565,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -566,9 +578,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// C2S FIN Packet
@@ -578,10 +591,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -603,7 +617,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -611,23 +625,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -641,11 +656,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -654,9 +669,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// S2C FIN Packet
@@ -666,10 +682,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -691,7 +708,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -699,23 +716,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif

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

@@ -1,24 +1,16 @@
// UDP state machine test: init -> opening -> active -> closing
#include <gtest/gtest.h>
#include "tuple.h"
#include "packet_internal.h"
#include "packet_parser.h"
#include "session_internal.h"
#include "default_config.h"
#include "test_packets.h"
#include "test_utils.h"
#if 1
TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
{
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S REQ Packet
printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -27,9 +19,10 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
@@ -57,10 +50,11 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -82,7 +76,7 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0);
@@ -90,24 +84,25 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // active -> closing
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // active -> closing
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif

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

@@ -1,12 +1,5 @@
// UDP state machine test: init -> opening -> closing
#include <gtest/gtest.h>
#include "tuple.h"
#include "packet_internal.h"
#include "packet_parser.h"
#include "session_internal.h"
#include "default_config.h"
#include "test_packets.h"
#include "test_utils.h"
/******************************************************************************
* case: UDP init -> opening (by C2S Packet)
@@ -19,11 +12,11 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S REQ Packet
printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -32,9 +25,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
@@ -57,7 +51,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 1);
@@ -65,24 +59,25 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // opening -> closing
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // opening -> closing
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -97,11 +92,11 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
char buffer[1024] = {0};
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
struct session_manager_stat *sess_mgr_stat = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// S2C RESP Packet
printf("\n=> Packet Parse: UDP S2C RESP packet\n");
@@ -110,9 +105,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0);
@@ -135,7 +131,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
session_print(sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1);
EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 1);
@@ -143,8 +139,8 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // opening -> closing
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // opening -> closing
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
@@ -152,17 +148,17 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_rte_free_session(sess_mgr_rte, sess);
// check stat
sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 0);
EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0);
EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
session_manager_runtime_free(sess_mgr_rt);
session_manager_rte_free(sess_mgr_rte);
}
#endif

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

@@ -1,21 +1,14 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "packet_internal.h"
#include "packet_parser.h"
#include "session_internal.h"
#include "default_config.h"
#include "test_packets.h"
#include "test_utils.h"
#if 1
TEST(TIMEOUT, TCP_TIMEOUT_DATA)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -24,9 +17,10 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// C2S DATA Packet
@@ -36,22 +30,24 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_runtime_free(sess_mgr_rt);
// free session
session_manager_rte_free_session(sess_mgr_rte, sess);
session_manager_rte_free(sess_mgr_rte);
}
#endif

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

@@ -1,21 +1,14 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "packet_internal.h"
#include "packet_parser.h"
#include "session_internal.h"
#include "default_config.h"
#include "test_packets.h"
#include "test_utils.h"
#if 1
TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -24,22 +17,24 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_runtime_free(sess_mgr_rt);
// free session
session_manager_rte_free_session(sess_mgr_rte, sess);
session_manager_rte_free(sess_mgr_rte);
}
#endif

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

@@ -1,21 +1,14 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "packet_internal.h"
#include "packet_parser.h"
#include "session_internal.h"
#include "default_config.h"
#include "test_packets.h"
#include "test_utils.h"
#if 1
TEST(TIMEOUT, TCP_TIMEOUT_INIT)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -24,22 +17,24 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); // opening -> closing
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); // opening -> closing
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_runtime_free(sess_mgr_rt);
// free session
session_manager_rte_free_session(sess_mgr_rte, sess);
session_manager_rte_free(sess_mgr_rte);
}
#endif

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

@@ -1,21 +1,14 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "packet_internal.h"
#include "packet_parser.h"
#include "session_internal.h"
#include "default_config.h"
#include "test_packets.h"
#include "test_utils.h"
#if 1
TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S REQ Packet
printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -24,22 +17,24 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // opening -> closing
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // opening -> closing
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_runtime_free(sess_mgr_rt);
// free session
session_manager_rte_free_session(sess_mgr_rte, sess);
session_manager_rte_free(sess_mgr_rte);
}
#endif
@@ -48,10 +43,10 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
{
struct packet pkt;
struct session *sess = NULL;
struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_rte *sess_mgr_rte = NULL;
sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rt != NULL);
sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(sess_mgr_rte != NULL);
// C2S REQ Packet
printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -60,9 +55,10 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
printf("<= Packet Parse: done\n\n");
// lookup session
EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
// new session
sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
EXPECT_TRUE(sess);
// S2C RESP Packet
@@ -72,22 +68,24 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
printf("<= Packet Parse: done\n\n");
// lookup session
sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
EXPECT_TRUE(sess);
// update session
EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
// expire session
EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // active -> closing
sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // active -> closing
sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess);
// free session
session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_runtime_free(sess_mgr_rt);
// free session
session_manager_rte_free_session(sess_mgr_rte, sess);
session_manager_rte_free(sess_mgr_rte);
}
#endif

87
infra/session_manager/test/test_packets.h → infra/session_manager/test/test_utils.h
View File

@@ -1,10 +1,97 @@
#pragma once
#include <gtest/gtest.h>
#ifdef __cplusplus
extern "C"
{
#endif
#include "tuple.h"
#include "packet_parser.h"
#include "packet_internal.h"
#include "utils_internal.h"
#include "session_pool.h"
#include "session_timer.h"
#include "session_table.h"
#include "session_filter.h"
#include "session_internal.h"
#include "session_transition.h"
#include "session_manager_cfg.h"
#include "session_manager_rte.h"
__attribute__((unused)) static struct session_manager_cfg sess_mgr_cfg = {
.instance_id = 1,
.thread_num = 1,
.session_id_seed = 0xFFFFF,
.tcp_session_max = 256,
.udp_session_max = 256,
.evict_old_on_tcp_table_limit = 1,
.evict_old_on_udp_table_limit = 1,
.expire_period_ms = 0,
.expire_batch_max = 1024,
.tcp_timeout_ms =
{
.init = 1,
.handshake = 2,
.data = 3,
.half_closed = 4,
.time_wait = 5,
.discard_default = 6,
.unverified_rst = 7,
},
.udp_timeout_ms =
{
.data = 8,
.discard_default = 0,
},
.duplicated_packet_bloom_filter =
{
.enable = 1,
.capacity = 1000,
.time_window_ms = 10,
.error_rate = 0.0001,
},
.evicted_session_bloom_filter =
{
.enable = 1,
.capacity = 1000,
.time_window_ms = 10,
.error_rate = 0.0001,
},
.tcp_reassembly =
{
.enable = 1,
.timeout_ms = 1000,
.buffered_segments_max = 16,
},
};
static inline void packet_overwrite_ipid(struct packet *pkt, uint16_t ip_id)
{
const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4);
EXPECT_TRUE(ipv4_layer);
struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
hdr->ip_id = htons(ip_id);
}
static inline void packet_overwrite_v4_saddr(struct packet *pkt, struct in_addr *addr)
{
const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4);
EXPECT_TRUE(ipv4_layer);
struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
hdr->ip_src = *addr;
}
/******************************************************************************
* test packet: HTTP www.example.com
******************************************************************************/