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

refactor(session manager): rename original session_manager to session_manager_runtime

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

4
infra/ip_reassembly/ip_reassembly.h
View File

@@ -16,7 +16,7 @@ struct ip_reassembly_config
uint64_t ip_frag_expire_polling_limit; // range: [1, 1024] uint64_t ip_frag_expire_polling_limit; // range: [1, 1024]
}; };
struct __attribute__((aligned(64))) ip_reassembly_stat struct ip_reassembly_stat
{ {
// IPv4 frag stat // IPv4 frag stat
uint64_t ip4_defrags_expected; uint64_t ip4_defrags_expected;
@@ -47,7 +47,7 @@ struct __attribute__((aligned(64))) ip_reassembly_stat
uint64_t ip6_frags_bypass_no_buffer; uint64_t ip6_frags_bypass_no_buffer;
uint64_t ip6_frags_bypass_dup_fist_frag; uint64_t ip6_frags_bypass_dup_fist_frag;
uint64_t ip6_frags_bypass_dup_last_frag; uint64_t ip6_frags_bypass_dup_last_frag;
}; } __attribute__((aligned(64)));
struct ip_reassembly_config *ip_reassembly_config_new(const char *toml_file); struct ip_reassembly_config *ip_reassembly_config_new(const char *toml_file);
void ip_reassembly_config_free(struct ip_reassembly_config *cfg); void ip_reassembly_config_free(struct ip_reassembly_config *cfg);

4
infra/packet_io/packet_io.h
View File

@@ -10,7 +10,7 @@ extern "C"
#include "utils.h" #include "utils.h"
struct __attribute__((aligned(64))) packet_io_stat struct packet_io_stat
{ {
// device packet // device packet
uint64_t pkts_rx; uint64_t pkts_rx;
@@ -44,7 +44,7 @@ struct __attribute__((aligned(64))) packet_io_stat
uint64_t ctrl_pkts_tx; uint64_t ctrl_pkts_tx;
uint64_t ctrl_bytes_tx; uint64_t ctrl_bytes_tx;
}; } __attribute__((aligned(64)));
enum packet_io_mode enum packet_io_mode
{ {

46
infra/packet_manager/packet_manager_private.h Normal file
View File

@@ -0,0 +1,46 @@
#pragma once
#ifdef __cplusplus
extern "C"
{
#endif
#include "stellar/packet_manager.h"
#define PACKET_QUEUE_MAX (PACKET_STAGE_MAX + 1)
struct packet_manager *packet_manager_new(struct mq_schema *mq_schema, const char *toml_file);
void packet_manager_free(struct packet_manager *pkt_mgr);
void packet_manager_runtime_init(struct packet_manager_runtime *pkt_mgr_rt, struct mq_runtime *mq_rt);
void packet_manager_runtime_ingress(struct packet_manager_runtime *pkt_mgr_rt, struct packet *pkt);
struct packet *packet_manager_runtime_egress(struct packet_manager_runtime *pkt_mgr_rt);
void packet_manager_runtime_dispatch(struct packet_manager_runtime *pkt_mgr_rt);
/******************************************************************************
* for gtest
******************************************************************************/
struct packet_manager_stat
{
struct
{
uint64_t pkts_ingress;
uint64_t pkts_egress;
} total;
struct
{
uint64_t pkts_in; // include the packets that are scheduled
uint64_t pkts_out; // include the packets that are claimed
uint64_t pkts_claim;
uint64_t pkts_schedule;
} queue[PACKET_QUEUE_MAX]; // the last queue is for sending packets
} __attribute__((aligned(64)));
const char *packet_stage_to_str(enum packet_stage stage);
void packet_manager_runtime_print_stat(struct packet_manager_runtime *runtime);
struct packet_manager_stat *packet_manager_runtime_get_stat(struct packet_manager_runtime *runtime);
#ifdef __cplusplus
}
#endif

4
infra/session_manager/session_internal.h
View File

@@ -71,8 +71,8 @@ struct session
enum session_type sess_type; enum session_type sess_type;
enum session_state state; enum session_state state;
enum closing_reason reason; enum closing_reason reason;
struct session_manager *mgr; struct session_manager_runtime *sess_mgr_rt;
struct session_manager_stat *mgr_stat; struct session_manager_stat *sess_mgr_stat;
}; };
TAILQ_HEAD(session_list, session); TAILQ_HEAD(session_list, session);

884
infra/session_manager/session_manager.c
View File

File diff suppressed because it is too large Load Diff

49
infra/session_manager/session_manager.h
View File

@@ -61,7 +61,7 @@ struct session_manager_config
} tcp_reassembly; } tcp_reassembly;
}; };
struct __attribute__((aligned(64))) session_manager_stat struct session_manager_stat
{ {
// TCP session // TCP session
uint64_t history_tcp_sessions; uint64_t history_tcp_sessions;
@@ -104,7 +104,7 @@ struct __attribute__((aligned(64))) session_manager_stat
uint64_t tcp_segs_reordered; // sum uint64_t tcp_segs_reordered; // sum
uint64_t tcp_segs_buffered; // sum uint64_t tcp_segs_buffered; // sum
uint64_t tcp_segs_freed; // sum uint64_t tcp_segs_freed; // sum
}; } __attribute__((aligned(64)));
enum session_scan_flags enum session_scan_flags
{ {
@@ -142,34 +142,35 @@ struct session_scan_opts
uint64_t last_pkt_time_ms[2]; uint64_t last_pkt_time_ms[2];
}; };
// new/free/print config
struct session_manager_config *session_manager_config_new(const char *toml_file); struct session_manager_config *session_manager_config_new(const char *toml_file);
void session_manager_config_free(struct session_manager_config *cfg); void session_manager_config_free(struct session_manager_config *sess_mgr_cfg);
void session_manager_config_print(struct session_manager_config *cfg); void session_manager_config_print(struct session_manager_config *sess_mgr_cfg);
struct session_manager; // new/free runtime
struct session_manager *session_manager_new(const struct session_manager_config *cfg, uint64_t now_ms); struct session_manager_runtime;
void session_manager_free(struct session_manager *mgr); struct session_manager_runtime *session_manager_runtime_new(const struct session_manager_config *sess_mgr_cfg, uint64_t now_ms);
void session_manager_runtime_free(struct session_manager_runtime *sess_mgr_rt);
void session_manager_record_duplicated_packet(struct session_manager *mgr, const struct packet *pkt); // new/free/lookup/update/clean session
struct session *session_manager_runtime_new_session(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt, uint64_t now_ms);
void session_manager_runtime_free_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess);
struct session *session_manager_runtime_lookup_session_by_packet(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt);
struct session *session_manager_runtime_lookup_session_by_id(struct session_manager_runtime *sess_mgr_rt, uint64_t sess_id);
int session_manager_runtime_update_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess, const struct packet *pkt, uint64_t now_ms);
struct session *session_manager_runtime_get_expired_session(struct session_manager_runtime *sess_mgr_rt, uint64_t now_ms);
struct session *session_manager_runtime_get_evicted_session(struct session_manager_runtime *sess_mgr_rt);
uint64_t session_manager_runtime_clean_session(struct session_manager_runtime *sess_mgr_rt, uint64_t now_ms, struct session *cleaned_sess[], uint64_t array_size);
struct session *session_manager_new_session(struct session_manager *mgr, const struct packet *pkt, uint64_t now_ms); // stat
void session_manager_free_session(struct session_manager *mgr, struct session *sess); struct session_manager_stat *session_manager_runtime_get_stat(struct session_manager_runtime *sess_mgr_rt);
void session_manager_runtime_print_stat(struct session_manager_runtime *sess_mgr_rt);
struct session *session_manager_lookup_session_by_packet(struct session_manager *mgr, const struct packet *pkt); // scan
struct session *session_manager_lookup_session_by_id(struct session_manager *mgr, uint64_t sess_id); uint64_t session_manager_runtime_scan(const struct session_manager_runtime *sess_mgr_rt, const struct session_scan_opts *opts, uint64_t mached_sess_ids[], uint64_t array_size);
int session_manager_update_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, uint64_t now_ms);
// return session need free by session_manager_free_session() // duplicated packet
struct session *session_manager_get_expired_session(struct session_manager *mgr, uint64_t now_ms); void session_manager_runtime_record_duplicated_packet(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt);
struct session *session_manager_get_evicted_session(struct session_manager *mgr);
uint64_t session_manager_clean_session(struct session_manager *mgr, uint64_t now_ms, struct session *cleaned_sess[], uint64_t array_size);
// return 0: have already timeout session
// return >0: next expire interval
uint64_t session_manager_get_expire_interval(struct session_manager *mgr);
struct session_manager_stat *session_manager_stat(struct session_manager *mgr);
uint64_t session_manager_scan(const struct session_manager *mgr, const struct session_scan_opts *opts, uint64_t mached_sess_ids[], uint64_t array_size);
#ifdef __cplusplus #ifdef __cplusplus
} }

8
infra/session_manager/session_utils.c
View File

@@ -206,7 +206,7 @@ struct tcp_segment *session_get_tcp_segment(struct session *sess)
if (half->in_order.data != NULL && half->in_order.len > 0 && half->in_order_ref == 0) if (half->in_order.data != NULL && half->in_order.len > 0 && half->in_order_ref == 0)
{ {
sess->mgr_stat->tcp_segs_consumed++; sess->sess_mgr_stat->tcp_segs_consumed++;
half->in_order_ref++; half->in_order_ref++;
return &half->in_order; return &half->in_order;
} }
@@ -219,8 +219,8 @@ struct tcp_segment *session_get_tcp_segment(struct session *sess)
session_inc_stat(sess, type, STAT_TCP_PAYLOADS_REORDERED, seg->len); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_REORDERED, seg->len);
// TODO // TODO
sess->mgr_stat->tcp_segs_consumed++; sess->sess_mgr_stat->tcp_segs_consumed++;
sess->mgr_stat->tcp_segs_reordered++; sess->sess_mgr_stat->tcp_segs_reordered++;
} }
return seg; return seg;
} }
@@ -246,7 +246,7 @@ void session_free_tcp_segment(struct session *sess, struct tcp_segment *seg)
{ {
session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RELEASED, 1); session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RELEASED, 1);
session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RELEASED, seg->len); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RELEASED, seg->len);
sess->mgr_stat->tcp_segs_freed++; sess->sess_mgr_stat->tcp_segs_freed++;
tcp_segment_free(seg); tcp_segment_free(seg);
} }

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

@@ -9,7 +9,7 @@ extern "C"
#include "session_manager.h" #include "session_manager.h"
static struct session_manager_config cfg = { static struct session_manager_config sess_mgr_cfg = {
.session_id_seed = 0xFFFFF, .session_id_seed = 0xFFFFF,
.tcp_session_max = 256, .tcp_session_max = 256,
.udp_session_max = 256, .udp_session_max = 256,

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

@@ -263,11 +263,11 @@ TEST(CASE, TCP_FAST_OPEN)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S fast open packet\n"); printf("\n=> Packet Parse: TCP C2S fast open packet\n");
@@ -276,9 +276,9 @@ TEST(CASE, TCP_FAST_OPEN)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
@@ -347,32 +347,32 @@ TEST(CASE, TCP_FAST_OPEN)
session_free_tcp_segment(sess, seg); session_free_tcp_segment(sess, seg);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL); // opening -> closing 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_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data); // closing -> closed sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif

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

@@ -19,11 +19,11 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
{ {
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -32,14 +32,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
// C2S SYN dup Packet // C2S SYN dup Packet
printf("\n=> Packet Parse: TCP C2S SYN dup packet\n"); printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
@@ -48,14 +48,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == -1); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == -1);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 1); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
// C2S SYN retransmission Packet // C2S SYN retransmission Packet
printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n"); printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
@@ -67,16 +67,16 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 1); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -85,11 +85,11 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
{ {
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// S2C SYNACK Packet // S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -98,14 +98,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
// S2C SYNACK dup Packet // S2C SYNACK dup Packet
printf("\n=> Packet Parse: TCP S2C SYNACK dup packet\n"); printf("\n=> Packet Parse: TCP S2C SYNACK dup packet\n");
@@ -114,14 +114,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == -1); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == -1);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 1); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
// S2C SYNACK retransmission Packet // S2C SYNACK retransmission Packet
printf("\n=> Packet Parse: TCP S2C SYNACK retransmission packet\n"); printf("\n=> Packet Parse: TCP S2C SYNACK retransmission packet\n");
@@ -133,16 +133,16 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 1); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -151,12 +151,12 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
{ {
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
char syn_retransmission[1500] = {0}; char syn_retransmission[1500] = {0};
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -165,14 +165,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
// C2S SYN retransmission Packet // C2S SYN retransmission Packet
printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n"); printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
@@ -183,14 +183,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
// C2S SYN retransmission Packet // C2S SYN retransmission Packet
printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n"); printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
@@ -201,14 +201,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
// C2S SYN dup Packet // C2S SYN dup Packet
printf("\n=> Packet Parse: TCP C2S SYN dup packet\n"); printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
@@ -217,16 +217,16 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -235,14 +235,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
{ {
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
struct session_manager_config _cfg; struct session_manager_config _cfg;
memcpy(&_cfg, &cfg, sizeof(struct session_manager_config)); memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
_cfg.duplicated_packet_bloom_filter.enable = 0; _cfg.duplicated_packet_bloom_filter.enable = 0;
mgr = session_manager_new(&_cfg, 1); sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -251,14 +251,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
// C2S SYN dup Packet // C2S SYN dup Packet
printf("\n=> Packet Parse: TCP C2S SYN dup packet\n"); printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
@@ -267,16 +267,16 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -285,14 +285,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
{ {
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
struct session_manager_config _cfg; struct session_manager_config _cfg;
memcpy(&_cfg, &cfg, sizeof(struct session_manager_config)); memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
_cfg.duplicated_packet_bloom_filter.enable = 0; _cfg.duplicated_packet_bloom_filter.enable = 0;
mgr = session_manager_new(&_cfg, 1); sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// S2C SYNACK Packet // S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -301,14 +301,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
// S2C SYNACK dup Packet // S2C SYNACK dup Packet
printf("\n=> Packet Parse: TCP S2C SYNACK dup packet\n"); printf("\n=> Packet Parse: TCP S2C SYNACK dup packet\n");
@@ -317,16 +317,16 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif

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

@@ -19,15 +19,15 @@ static void packet_set_ip_src_addr(struct packet *pkt, uint32_t addr)
TEST(TCP_OVERLOAD, EVICT_OLD_SESS) TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
{ {
struct packet pkt; struct packet pkt;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
struct session_manager_config _cfg; struct session_manager_config _cfg;
memcpy(&_cfg, &cfg, sizeof(struct session_manager_config)); memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
_cfg.tcp_session_max = RX_BURST_MAX * 2; _cfg.tcp_session_max = RX_BURST_MAX * 2;
_cfg.udp_session_max = RX_BURST_MAX * 2; _cfg.udp_session_max = RX_BURST_MAX * 2;
mgr = session_manager_new(&_cfg, 1); sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -39,21 +39,21 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
for (uint32_t i = 0; i < _cfg.tcp_session_max; i++) for (uint32_t i = 0; i < _cfg.tcp_session_max; i++)
{ {
packet_set_ip_src_addr(&pkt, i); packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1)); EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
} }
printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max); printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == _cfg.tcp_session_max); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _cfg.tcp_session_max);
EXPECT_TRUE(stat->tcp_sess_opening == RX_BURST_MAX); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
EXPECT_TRUE(stat->tcp_sess_closed == RX_BURST_MAX); // have evicted, have't free EXPECT_TRUE(sess_mgr_stat->tcp_sess_closed == RX_BURST_MAX); // have evicted, have't free
EXPECT_TRUE(stat->tcp_sess_evicted == RX_BURST_MAX); EXPECT_TRUE(sess_mgr_stat->tcp_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->tcp_pkts_bypass_table_full == 0); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_table_full == 0);
EXPECT_TRUE(stat->tcp_pkts_bypass_session_not_found == 0); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_session_not_found == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -61,16 +61,16 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
TEST(TCP_OVERLOAD, EVICT_NEW_SESS) TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
{ {
struct packet pkt; struct packet pkt;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
struct session_manager_config _cfg; struct session_manager_config _cfg;
memcpy(&_cfg, &cfg, sizeof(struct session_manager_config)); memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
_cfg.tcp_session_max = RX_BURST_MAX * 2; _cfg.tcp_session_max = RX_BURST_MAX * 2;
_cfg.udp_session_max = RX_BURST_MAX * 2; _cfg.udp_session_max = RX_BURST_MAX * 2;
_cfg.evict_old_on_tcp_table_limit = 0; _cfg.evict_old_on_tcp_table_limit = 0;
mgr = session_manager_new(&_cfg, 1); sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -82,40 +82,40 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
for (uint32_t i = 0; i < _cfg.tcp_session_max; i++) for (uint32_t i = 0; i < _cfg.tcp_session_max; i++)
{ {
packet_set_ip_src_addr(&pkt, i); packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1)); EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
} }
printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max); printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == _cfg.tcp_session_max); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _cfg.tcp_session_max);
EXPECT_TRUE(stat->tcp_sess_opening == _cfg.tcp_session_max); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _cfg.tcp_session_max);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
EXPECT_TRUE(stat->tcp_sess_closed == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closed == 0);
EXPECT_TRUE(stat->tcp_sess_evicted == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_evicted == 0);
EXPECT_TRUE(stat->tcp_pkts_bypass_table_full == 0); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_table_full == 0);
EXPECT_TRUE(stat->tcp_pkts_bypass_session_not_found == 0); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_session_not_found == 0);
// table full, evict new session // table full, evict new session
for (uint32_t i = 0; i < RX_BURST_MAX; i++) for (uint32_t i = 0; i < RX_BURST_MAX; i++)
{ {
packet_set_ip_src_addr(&pkt, _cfg.tcp_session_max + i); packet_set_ip_src_addr(&pkt, _cfg.tcp_session_max + i);
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL); EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1) == NULL);
} }
printf("=> Session Manager: after evicte new session\n"); printf("=> Session Manager: after evicte new session\n");
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == _cfg.tcp_session_max); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _cfg.tcp_session_max);
EXPECT_TRUE(stat->tcp_sess_opening == _cfg.tcp_session_max); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _cfg.tcp_session_max);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
EXPECT_TRUE(stat->tcp_sess_closed == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closed == 0);
EXPECT_TRUE(stat->tcp_sess_evicted == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_evicted == 0);
EXPECT_TRUE(stat->tcp_pkts_bypass_table_full == RX_BURST_MAX); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_table_full == RX_BURST_MAX);
EXPECT_TRUE(stat->tcp_pkts_bypass_session_not_found == 0); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_session_not_found == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif

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

@@ -20,15 +20,15 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
{ {
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
struct session_manager_config _cfg; struct session_manager_config _cfg;
memcpy(&_cfg, &cfg, sizeof(struct session_manager_config)); memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
_cfg.tcp_session_max = RX_BURST_MAX * 2; _cfg.tcp_session_max = RX_BURST_MAX * 2;
_cfg.udp_session_max = RX_BURST_MAX * 2; _cfg.udp_session_max = RX_BURST_MAX * 2;
mgr = session_manager_new(&_cfg, 1); sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S REQ Packet // C2S REQ Packet
printf("\n=> Packet Parse: UDP C2S REQ packet\n"); printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -40,27 +40,27 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
for (uint32_t i = 0; i < _cfg.udp_session_max; i++) for (uint32_t i = 0; i < _cfg.udp_session_max; i++)
{ {
packet_set_ip_src_addr(&pkt, i); packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1)); EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
} }
printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max); printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->udp_sess_used == _cfg.udp_session_max); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _cfg.udp_session_max);
EXPECT_TRUE(stat->udp_sess_opening == RX_BURST_MAX); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
EXPECT_TRUE(stat->udp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess_closed == RX_BURST_MAX); // have evicted, have't free EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == RX_BURST_MAX); // have evicted, have't free
EXPECT_TRUE(stat->udp_sess_evicted == RX_BURST_MAX); EXPECT_TRUE(sess_mgr_stat->udp_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_pkts_bypass_table_full == 0); EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == 0);
EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == 0); EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == 0);
// evicted session // evicted session
while (1) while (1)
{ {
sess = session_manager_get_evicted_session(mgr); sess = session_manager_runtime_get_evicted_session(sess_mgr_rt);
if (sess) if (sess)
{ {
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
} }
else else
{ {
@@ -71,38 +71,38 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
for (uint32_t i = 0; i < RX_BURST_MAX; i++) for (uint32_t i = 0; i < RX_BURST_MAX; i++)
{ {
packet_set_ip_src_addr(&pkt, i); packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL); // hit evicted session, can't renew session EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1) == NULL); // hit evicted session, can't renew session
} }
printf("=> Session Manager: after readd %d evicted sessions\n", RX_BURST_MAX); printf("=> Session Manager: after readd %d evicted sessions\n", RX_BURST_MAX);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->udp_sess_used == RX_BURST_MAX); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_sess_opening == RX_BURST_MAX); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
EXPECT_TRUE(stat->udp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess_closed == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == 0);
EXPECT_TRUE(stat->udp_sess_evicted == RX_BURST_MAX); EXPECT_TRUE(sess_mgr_stat->udp_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_pkts_bypass_table_full == 0); EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == 0);
EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX); EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX);
// evicted session timeout // evicted session timeout
packet_set_ip_src_addr(&pkt, 0); packet_set_ip_src_addr(&pkt, 0);
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1 + _cfg.evicted_session_bloom_filter.time_window_ms)); EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1 + _cfg.evicted_session_bloom_filter.time_window_ms));
printf("=> Session Manager: after evicted session timeout\n"); printf("=> Session Manager: after evicted session timeout\n");
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->udp_sess_used == RX_BURST_MAX + 1); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == RX_BURST_MAX + 1);
EXPECT_TRUE(stat->udp_sess_opening == RX_BURST_MAX); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
EXPECT_TRUE(stat->udp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess_closed == 1); // have evicted, have't free EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == 1); // have evicted, have't free
EXPECT_TRUE(stat->udp_sess_evicted == RX_BURST_MAX + 1); EXPECT_TRUE(sess_mgr_stat->udp_sess_evicted == RX_BURST_MAX + 1);
EXPECT_TRUE(stat->udp_pkts_bypass_table_full == 0); EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == 0);
EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX); EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -110,16 +110,16 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
TEST(UDP_OVERLOAD, EVICT_NEW_SESS) TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
{ {
struct packet pkt; struct packet pkt;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
struct session_manager_config _cfg; struct session_manager_config _cfg;
memcpy(&_cfg, &cfg, sizeof(struct session_manager_config)); memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
_cfg.tcp_session_max = RX_BURST_MAX * 2; _cfg.tcp_session_max = RX_BURST_MAX * 2;
_cfg.udp_session_max = RX_BURST_MAX * 2; _cfg.udp_session_max = RX_BURST_MAX * 2;
_cfg.evict_old_on_udp_table_limit = 0; _cfg.evict_old_on_udp_table_limit = 0;
mgr = session_manager_new(&_cfg, 1); sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S REQ Packet // C2S REQ Packet
printf("\n=> Packet Parse: UDP C2S REQ packet\n"); printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -131,43 +131,43 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
for (uint32_t i = 0; i < _cfg.udp_session_max; i++) for (uint32_t i = 0; i < _cfg.udp_session_max; i++)
{ {
packet_set_ip_src_addr(&pkt, i); packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1)); EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
} }
printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max); printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->udp_sess_used == _cfg.udp_session_max); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _cfg.udp_session_max);
EXPECT_TRUE(stat->udp_sess_opening == _cfg.udp_session_max); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _cfg.udp_session_max);
EXPECT_TRUE(stat->udp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
EXPECT_TRUE(stat->udp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess_closed == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == 0);
EXPECT_TRUE(stat->udp_sess_evicted == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_evicted == 0);
EXPECT_TRUE(stat->udp_pkts_bypass_table_full == 0); EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == 0);
EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == 0); EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == 0);
// evicted session // evicted session
EXPECT_TRUE(session_manager_get_evicted_session(mgr) == NULL); EXPECT_TRUE(session_manager_runtime_get_evicted_session(sess_mgr_rt) == NULL);
// table full, evict new session // table full, evict new session
for (uint32_t i = 0; i < RX_BURST_MAX; i++) for (uint32_t i = 0; i < RX_BURST_MAX; i++)
{ {
packet_set_ip_src_addr(&pkt, _cfg.udp_session_max + i); packet_set_ip_src_addr(&pkt, _cfg.udp_session_max + i);
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL); EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1) == NULL);
} }
printf("=> Session Manager: after readd %d evicted session\n", RX_BURST_MAX); printf("=> Session Manager: after readd %d evicted session\n", RX_BURST_MAX);
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->udp_sess_used == _cfg.udp_session_max); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _cfg.udp_session_max);
EXPECT_TRUE(stat->udp_sess_opening == _cfg.udp_session_max); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _cfg.udp_session_max);
EXPECT_TRUE(stat->udp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
EXPECT_TRUE(stat->udp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess_closed == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == 0);
EXPECT_TRUE(stat->udp_sess_evicted == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_evicted == 0);
EXPECT_TRUE(stat->udp_pkts_bypass_table_full == RX_BURST_MAX); EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == 0); EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif

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

@@ -13,13 +13,13 @@ static inline void packet_overwrite_src_addr(struct packet *pkt, struct in_addr
hdr->ip_src = addr; hdr->ip_src = addr;
} }
static inline void mached_session_print(const char *title, struct session_manager *mgr, uint64_t mached_sess_ids[], uint64_t mached_sess_num) static inline void mached_session_print(const char *title, struct session_manager_runtime *sess_mgr_rt, uint64_t mached_sess_ids[], uint64_t mached_sess_num)
{ {
struct session *sess = NULL; struct session *sess = NULL;
printf("%-*s mached_sess_num: %lu\n", 40, title, mached_sess_num); printf("%-*s mached_sess_num: %lu\n", 40, title, mached_sess_num);
for (uint64_t i = 0; i < mached_sess_num; i++) for (uint64_t i = 0; i < mached_sess_num; i++)
{ {
sess = session_manager_lookup_session_by_id(mgr, mached_sess_ids[i]); sess = session_manager_runtime_lookup_session_by_id(sess_mgr_rt, mached_sess_ids[i]);
printf("session id: %lu, addr: %s, type: %s, state: %s, start: %lu, last: %lu\n", 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_ids[i], session_get0_readable_addr(sess),
session_type_to_str(session_get_type(sess)), session_type_to_str(session_get_type(sess)),
@@ -37,7 +37,7 @@ TEST(SESS_MGR_SCAN, OPTS)
uint64_t mached_sess_ids[1460]; uint64_t mached_sess_ids[1460];
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct in_addr v4_src_addr1 = {}; struct in_addr v4_src_addr1 = {};
struct in_addr v4_src_addr2 = {}; struct in_addr v4_src_addr2 = {};
@@ -85,16 +85,16 @@ TEST(SESS_MGR_SCAN, OPTS)
inet_pton(AF_INET6, "cafe::0000", &v6_dst_subnet_beg); inet_pton(AF_INET6, "cafe::0000", &v6_dst_subnet_beg);
inet_pton(AF_INET6, "cafe::ffff", &v6_dst_subnet_end); inet_pton(AF_INET6, "cafe::ffff", &v6_dst_subnet_end);
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// new session // new session
memset(&pkt, 0, sizeof(pkt)); memset(&pkt, 0, sizeof(pkt));
memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn)); memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn)); packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn));
packet_overwrite_src_addr(&pkt, v4_src_addr1); packet_overwrite_src_addr(&pkt, v4_src_addr1);
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// new session // new session
@@ -102,8 +102,8 @@ TEST(SESS_MGR_SCAN, OPTS)
memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn)); memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn)); packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn));
packet_overwrite_src_addr(&pkt, v4_src_addr2); packet_overwrite_src_addr(&pkt, v4_src_addr2);
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
sess = session_manager_new_session(mgr, &pkt, 2); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 2);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// new session // new session
@@ -111,15 +111,15 @@ TEST(SESS_MGR_SCAN, OPTS)
memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn)); memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn)); packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn));
packet_overwrite_src_addr(&pkt, v4_src_addr3); packet_overwrite_src_addr(&pkt, v4_src_addr3);
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
sess = session_manager_new_session(mgr, &pkt, 3); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 3);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// new session // new session
memset(&pkt, 0, sizeof(pkt)); memset(&pkt, 0, sizeof(pkt));
packet_parse(&pkt, (const char *)ipv6_in_ipv6_udp, sizeof(ipv6_in_ipv6_udp)); packet_parse(&pkt, (const char *)ipv6_in_ipv6_udp, sizeof(ipv6_in_ipv6_udp));
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
sess = session_manager_new_session(mgr, &pkt, 4); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 4);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
struct session_scan_opts scan = {}; struct session_scan_opts scan = {};
@@ -134,42 +134,42 @@ TEST(SESS_MGR_SCAN, OPTS)
scan.flags = SESSION_SCAN_TYPE; scan.flags = SESSION_SCAN_TYPE;
scan.type = SESSION_TYPE_TCP; scan.type = SESSION_TYPE_TCP;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 3); EXPECT_TRUE(mached_sess_num == 3);
mached_session_print("SESSION_SCAN_TYPE: (TCP)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_TYPE: (TCP)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.type = SESSION_TYPE_UDP; scan.type = SESSION_TYPE_UDP;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 1); EXPECT_TRUE(mached_sess_num == 1);
mached_session_print("SESSION_SCAN_TYPE: (UDP)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_TYPE: (UDP)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
// SESSION_SCAN_STATE // SESSION_SCAN_STATE
scan.flags = SESSION_SCAN_STATE; scan.flags = SESSION_SCAN_STATE;
scan.state = SESSION_STATE_OPENING; scan.state = SESSION_STATE_OPENING;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 4); EXPECT_TRUE(mached_sess_num == 4);
mached_session_print("SESSION_SCAN_STATE: (OPENING)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_STATE: (OPENING)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.state = SESSION_STATE_ACTIVE; scan.state = SESSION_STATE_ACTIVE;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 0); EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_STATE: (ACTIVE)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_STATE: (ACTIVE)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.state = SESSION_STATE_CLOSING; scan.state = SESSION_STATE_CLOSING;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 0); EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_STATE: (CLOSING)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_STATE: (CLOSING)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.state = SESSION_STATE_DISCARD; scan.state = SESSION_STATE_DISCARD;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 0); EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_STATE: (DISCARD)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_STATE: (DISCARD)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.state = SESSION_STATE_CLOSED; scan.state = SESSION_STATE_CLOSED;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 0); EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_STATE: (CLOSED)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_STATE: (CLOSED)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
// SESSION_SCAN_SIP // SESSION_SCAN_SIP
scan.flags = SESSION_SCAN_SIP; scan.flags = SESSION_SCAN_SIP;
@@ -177,44 +177,44 @@ TEST(SESS_MGR_SCAN, OPTS)
scan.addr_family = AF_INET; scan.addr_family = AF_INET;
scan.src_addr[0].v4 = v4_src_addr1; scan.src_addr[0].v4 = v4_src_addr1;
scan.src_addr[1].v4 = v4_src_addr1; scan.src_addr[1].v4 = v4_src_addr1;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 1); EXPECT_TRUE(mached_sess_num == 1);
mached_session_print("SESSION_SCAN_SIP: (IPv4)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_SIP: (IPv4)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.addr_family = AF_INET; scan.addr_family = AF_INET;
scan.src_addr[0].v4 = v4_src_subnet_beg; scan.src_addr[0].v4 = v4_src_subnet_beg;
scan.src_addr[1].v4 = v4_src_subnet_end; scan.src_addr[1].v4 = v4_src_subnet_end;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 3); EXPECT_TRUE(mached_sess_num == 3);
mached_session_print("SESSION_SCAN_SIP: (IPv4 SUBNET)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_SIP: (IPv4 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.addr_family = AF_INET; scan.addr_family = AF_INET;
scan.src_addr[0].v4 = v4_min_addr; scan.src_addr[0].v4 = v4_min_addr;
scan.src_addr[1].v4 = v4_max_addr; scan.src_addr[1].v4 = v4_max_addr;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 3); EXPECT_TRUE(mached_sess_num == 3);
mached_session_print("SESSION_SCAN_SIP: (IPv4 MIN MAX)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_SIP: (IPv4 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.addr_family = AF_INET6; scan.addr_family = AF_INET6;
memcpy(&scan.src_addr[0].v6, &v6_src_addr, sizeof(v6_src_addr)); 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)); memcpy(&scan.src_addr[1].v6, &v6_src_addr, sizeof(v6_src_addr));
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 1); EXPECT_TRUE(mached_sess_num == 1);
mached_session_print("SESSION_SCAN_SIP: (IPv6)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_SIP: (IPv6)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.addr_family = AF_INET6; scan.addr_family = AF_INET6;
memcpy(&scan.src_addr[0].v6, &v6_src_subnet_beg, sizeof(v6_src_subnet_beg)); 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)); memcpy(&scan.src_addr[1].v6, &v6_src_subnet_end, sizeof(v6_src_subnet_end));
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 1); EXPECT_TRUE(mached_sess_num == 1);
mached_session_print("SESSION_SCAN_SIP: (IPv6 SUBNET)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_SIP: (IPv6 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.addr_family = AF_INET6; scan.addr_family = AF_INET6;
memcpy(&scan.src_addr[0].v6, &v6_min_addr, sizeof(v6_min_addr)); 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)); memcpy(&scan.src_addr[1].v6, &v6_max_addr, sizeof(v6_max_addr));
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 1); EXPECT_TRUE(mached_sess_num == 1);
mached_session_print("SESSION_SCAN_SIP: (IPv6 MIN MAX)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_SIP: (IPv6 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
// SESSION_SCAN_DIP // SESSION_SCAN_DIP
scan.flags = SESSION_SCAN_DIP; scan.flags = SESSION_SCAN_DIP;
@@ -222,126 +222,126 @@ TEST(SESS_MGR_SCAN, OPTS)
scan.addr_family = AF_INET; scan.addr_family = AF_INET;
scan.dst_addr[0].v4 = v4_dst_addr; scan.dst_addr[0].v4 = v4_dst_addr;
scan.dst_addr[1].v4 = v4_dst_addr; scan.dst_addr[1].v4 = v4_dst_addr;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 3); EXPECT_TRUE(mached_sess_num == 3);
mached_session_print("SESSION_SCAN_DIP: (IPv4)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_DIP: (IPv4)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.addr_family = AF_INET; scan.addr_family = AF_INET;
scan.dst_addr[0].v4 = v4_dst_subnet_beg; scan.dst_addr[0].v4 = v4_dst_subnet_beg;
scan.dst_addr[1].v4 = v4_dst_subnet_end; scan.dst_addr[1].v4 = v4_dst_subnet_end;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 3); EXPECT_TRUE(mached_sess_num == 3);
mached_session_print("SESSION_SCAN_DIP: (IPv4 SUBNET)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_DIP: (IPv4 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.addr_family = AF_INET; scan.addr_family = AF_INET;
scan.dst_addr[0].v4 = v4_min_addr; scan.dst_addr[0].v4 = v4_min_addr;
scan.dst_addr[1].v4 = v4_max_addr; scan.dst_addr[1].v4 = v4_max_addr;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 3); EXPECT_TRUE(mached_sess_num == 3);
mached_session_print("SESSION_SCAN_DIP: (IPv4 MIN MAX)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_DIP: (IPv4 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.addr_family = AF_INET6; scan.addr_family = AF_INET6;
memcpy(&scan.dst_addr[0].v6, &v6_dst_addr, sizeof(v6_dst_addr)); 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)); memcpy(&scan.dst_addr[1].v6, &v6_dst_addr, sizeof(v6_dst_addr));
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 1); EXPECT_TRUE(mached_sess_num == 1);
mached_session_print("SESSION_SCAN_DIP: (IPv6)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_DIP: (IPv6)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.addr_family = AF_INET6; scan.addr_family = AF_INET6;
memcpy(&scan.dst_addr[0].v6, &v6_dst_subnet_beg, sizeof(v6_dst_subnet_beg)); 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)); memcpy(&scan.dst_addr[1].v6, &v6_dst_subnet_end, sizeof(v6_dst_subnet_end));
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 1); EXPECT_TRUE(mached_sess_num == 1);
mached_session_print("SESSION_SCAN_DIP: (IPv6 SUBNET)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_DIP: (IPv6 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.addr_family = AF_INET6; scan.addr_family = AF_INET6;
memcpy(&scan.dst_addr[0].v6, &v6_min_addr, sizeof(v6_min_addr)); 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)); memcpy(&scan.dst_addr[1].v6, &v6_max_addr, sizeof(v6_max_addr));
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 1); EXPECT_TRUE(mached_sess_num == 1);
mached_session_print("SESSION_SCAN_DIP: (IPv6 MIN MAX)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_DIP: (IPv6 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
// SESSION_SCAN_SPORT // SESSION_SCAN_SPORT
scan.flags = SESSION_SCAN_SPORT; scan.flags = SESSION_SCAN_SPORT;
scan.src_port = htons(60111); scan.src_port = htons(60111);
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 3); EXPECT_TRUE(mached_sess_num == 3);
mached_session_print("SESSION_SCAN_SPORT: (HIT)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_SPORT: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.src_port = htons(60110); scan.src_port = htons(60110);
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 0); EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_SPORT: (MISS)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_SPORT: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
// SESSION_SCAN_DPORT // SESSION_SCAN_DPORT
scan.flags = SESSION_SCAN_DPORT; scan.flags = SESSION_SCAN_DPORT;
scan.dst_port = htons(80); scan.dst_port = htons(80);
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 3); EXPECT_TRUE(mached_sess_num == 3);
mached_session_print("SESSION_SCAN_DPORT: (HIT)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_DPORT: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.dst_port = htons(81); scan.dst_port = htons(81);
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 0); EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_DPORT: (MISS)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_DPORT: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
// SESSION_SCAN_CREATE_TIME // SESSION_SCAN_CREATE_TIME
scan.flags = SESSION_SCAN_CREATE_TIME; scan.flags = SESSION_SCAN_CREATE_TIME;
scan.create_time_ms[0] = 0; scan.create_time_ms[0] = 0;
scan.create_time_ms[1] = UINT64_MAX; scan.create_time_ms[1] = UINT64_MAX;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 4); EXPECT_TRUE(mached_sess_num == 4);
mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.create_time_ms[0] = 1; scan.create_time_ms[0] = 1;
scan.create_time_ms[1] = 2; scan.create_time_ms[1] = 2;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 2); EXPECT_TRUE(mached_sess_num == 2);
mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.create_time_ms[0] = 0; scan.create_time_ms[0] = 0;
scan.create_time_ms[1] = 0; scan.create_time_ms[1] = 0;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 0); EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.create_time_ms[0] = UINT64_MAX; scan.create_time_ms[0] = UINT64_MAX;
scan.create_time_ms[1] = UINT64_MAX; scan.create_time_ms[1] = UINT64_MAX;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 0); EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
// SESSION_SCAN_LAST_PKT_TIME // SESSION_SCAN_LAST_PKT_TIME
scan.flags = SESSION_SCAN_LAST_PKT_TIME; scan.flags = SESSION_SCAN_LAST_PKT_TIME;
scan.last_pkt_time_ms[0] = 0; scan.last_pkt_time_ms[0] = 0;
scan.last_pkt_time_ms[1] = UINT64_MAX; scan.last_pkt_time_ms[1] = UINT64_MAX;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 4); EXPECT_TRUE(mached_sess_num == 4);
mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.last_pkt_time_ms[0] = 1; scan.last_pkt_time_ms[0] = 1;
scan.last_pkt_time_ms[1] = 2; scan.last_pkt_time_ms[1] = 2;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 2); EXPECT_TRUE(mached_sess_num == 2);
mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.last_pkt_time_ms[0] = 0; scan.last_pkt_time_ms[0] = 0;
scan.last_pkt_time_ms[1] = 0; scan.last_pkt_time_ms[1] = 0;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 0); EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
scan.last_pkt_time_ms[0] = UINT64_MAX; scan.last_pkt_time_ms[0] = UINT64_MAX;
scan.last_pkt_time_ms[1] = UINT64_MAX; scan.last_pkt_time_ms[1] = UINT64_MAX;
mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
EXPECT_TRUE(mached_sess_num == 0); EXPECT_TRUE(mached_sess_num == 0);
mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", mgr, mached_sess_ids, mached_sess_num); mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif

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

@@ -26,10 +26,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
struct tcp_segment *seg; struct tcp_segment *seg;
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -38,9 +38,9 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
seg = session_get_tcp_segment(sess); seg = session_get_tcp_segment(sess);
@@ -53,10 +53,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
seg = session_get_tcp_segment(sess); seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL); EXPECT_TRUE(seg == NULL);
@@ -68,10 +68,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
seg = session_get_tcp_segment(sess); seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL); EXPECT_TRUE(seg == NULL);
@@ -83,10 +83,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 4) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0);
seg = session_get_tcp_segment(sess); seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL); EXPECT_TRUE(seg == NULL);
@@ -98,10 +98,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 5) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 5) == 0);
seg = session_get_tcp_segment(sess); seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL); EXPECT_TRUE(seg == NULL);
@@ -113,10 +113,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 6) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 6) == 0);
seg = session_get_tcp_segment(sess); seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL); EXPECT_TRUE(seg == NULL);
@@ -128,10 +128,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 7) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 7) == 0);
/* /*
* 11111111111111111111111111111111111111111111111111111111111111 * 11111111111111111111111111111111111111111111111111111111111111
@@ -198,16 +198,16 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
session_free_tcp_segment(sess, seg); session_free_tcp_segment(sess, seg);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 7 + cfg.tcp_timeout_ms.data) == NULL); // active -> closing 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_get_expired_session(mgr, 7 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); // closing -> closed sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 7 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -217,10 +217,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
struct tcp_segment *seg; struct tcp_segment *seg;
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -229,9 +229,9 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
seg = session_get_tcp_segment(sess); seg = session_get_tcp_segment(sess);
@@ -244,10 +244,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
seg = session_get_tcp_segment(sess); seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL); EXPECT_TRUE(seg == NULL);
@@ -259,10 +259,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
seg = session_get_tcp_segment(sess); seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg != NULL); EXPECT_TRUE(seg != NULL);
@@ -278,10 +278,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 4) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0);
seg = session_get_tcp_segment(sess); seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg != NULL); EXPECT_TRUE(seg != NULL);
@@ -291,16 +291,16 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
session_free_tcp_segment(sess, seg); session_free_tcp_segment(sess, seg);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 4 + cfg.tcp_timeout_ms.data) == NULL); // active -> closing 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_get_expired_session(mgr, 4 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); // closing -> closed sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 4 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif

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

@@ -8,7 +8,7 @@
#include "default_config.h" #include "default_config.h"
#include "test_packets.h" #include "test_packets.h"
static void build_active_tcp_session(struct session_manager *mgr, struct session *sess) static void build_active_tcp_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess)
{ {
struct packet pkt; struct packet pkt;
@@ -19,9 +19,9 @@ static void build_active_tcp_session(struct session_manager *mgr, struct session
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// C2S DATA Packet // C2S DATA Packet
@@ -31,10 +31,10 @@ static void build_active_tcp_session(struct session_manager *mgr, struct session
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
} }
/****************************************************************************** /******************************************************************************
@@ -47,14 +47,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet & C2S DATA Packet // C2S SYN Packet & C2S DATA Packet
build_active_tcp_session(mgr, sess); build_active_tcp_session(sess_mgr_rt, sess);
// C2S FIN Packet // C2S FIN Packet
printf("\n=> Packet Parse: TCP C2S FIN packet\n"); printf("\n=> Packet Parse: TCP C2S FIN packet\n");
@@ -63,10 +63,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
// S2C FIN Packet // S2C FIN Packet
printf("\n=> Packet Parse: TCP S2C FIN packet\n"); printf("\n=> Packet Parse: TCP S2C FIN packet\n");
@@ -75,10 +75,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -100,31 +100,31 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session // expire session
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.time_wait); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -138,14 +138,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet & C2S DATA Packet // C2S SYN Packet & C2S DATA Packet
build_active_tcp_session(mgr, sess); build_active_tcp_session(sess_mgr_rt, sess);
// C2S RST Packet // C2S RST Packet
printf("\n=> Packet Parse: TCP C2S RST packet\n"); printf("\n=> Packet Parse: TCP C2S RST packet\n");
@@ -160,10 +160,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -185,31 +185,31 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session // expire session
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.unverified_rst); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -223,14 +223,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet & C2S DATA Packet // C2S SYN Packet & C2S DATA Packet
build_active_tcp_session(mgr, sess); build_active_tcp_session(sess_mgr_rt, sess);
// S2C RST Packet // S2C RST Packet
printf("\n=> Packet Parse: TCP S2C RST packet\n"); printf("\n=> Packet Parse: TCP S2C RST packet\n");
@@ -245,10 +245,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -270,31 +270,31 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session // expire session
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.unverified_rst); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -306,42 +306,42 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT) TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
{ {
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet & C2S DATA Packet // C2S SYN Packet & C2S DATA Packet
build_active_tcp_session(mgr, sess); build_active_tcp_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 1);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL); EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -355,14 +355,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet & C2S DATA Packet // C2S SYN Packet & C2S DATA Packet
build_active_tcp_session(mgr, sess); build_active_tcp_session(sess_mgr_rt, sess);
// C2S FIN Packet // C2S FIN Packet
printf("\n=> Packet Parse: TCP C2S FIN packet\n"); printf("\n=> Packet Parse: TCP C2S FIN packet\n");
@@ -371,10 +371,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -396,31 +396,31 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session // expire session
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.half_closed); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -434,14 +434,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet & C2S DATA Packet // C2S SYN Packet & C2S DATA Packet
build_active_tcp_session(mgr, sess); build_active_tcp_session(sess_mgr_rt, sess);
// S2C FIN Packet // S2C FIN Packet
printf("\n=> Packet Parse: TCP S2C FIN packet\n"); printf("\n=> Packet Parse: TCP S2C FIN packet\n");
@@ -450,10 +450,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -475,31 +475,31 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session // expire session
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.half_closed); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif

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

@@ -18,11 +18,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -31,9 +31,9 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
@@ -56,32 +56,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL); // opening -> closing 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_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data); // closing -> closed sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -95,11 +95,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// S2C SYNACK Packet // S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -108,9 +108,9 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
@@ -133,32 +133,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake) == NULL); EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -172,11 +172,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -185,9 +185,9 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// S2C SYNACK Packet // S2C SYNACK Packet
@@ -197,10 +197,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -222,32 +222,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake) == NULL); EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -261,11 +261,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -274,9 +274,9 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// S2C SYNACK Packet // S2C SYNACK Packet
@@ -286,10 +286,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
// C2S ACK Packet // C2S ACK Packet
printf("\n=> Packet Parse: TCP C2S ACK packet\n"); printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -298,10 +298,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -323,32 +323,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data) == NULL); EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -364,11 +364,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -377,9 +377,9 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// C2S SYN Packet retransmission // C2S SYN Packet retransmission
@@ -394,10 +394,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -419,32 +419,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.init) == NULL); EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -460,11 +460,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// S2C SYNACK Packet // S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -473,9 +473,9 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// SYNACK Packet retransmission // SYNACK Packet retransmission
@@ -491,10 +491,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -516,32 +516,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake) == NULL); EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -555,11 +555,11 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -568,9 +568,9 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// C2S ACK Packet // C2S ACK Packet
@@ -580,10 +580,10 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -605,32 +605,32 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL); EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -644,11 +644,11 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// S2C SYNACK Packet // S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -657,9 +657,9 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// S2C ACK Packet // S2C ACK Packet
@@ -669,10 +669,10 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -694,32 +694,32 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL); EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif

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

@@ -14,11 +14,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
char buffer[1024]; char buffer[1024];
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -27,9 +27,9 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
@@ -58,10 +58,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer)); memset(buffer, 0, sizeof(buffer));
@@ -89,10 +89,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer)); memset(buffer, 0, sizeof(buffer));
@@ -120,10 +120,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 4) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer)); memset(buffer, 0, sizeof(buffer));
@@ -151,10 +151,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 5) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 5) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer)); memset(buffer, 0, sizeof(buffer));
@@ -182,10 +182,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 6) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 6) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer)); memset(buffer, 0, sizeof(buffer));
@@ -213,10 +213,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 7) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 7) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer)); memset(buffer, 0, sizeof(buffer));
@@ -244,10 +244,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 8) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 8) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer)); memset(buffer, 0, sizeof(buffer));
@@ -275,10 +275,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 9) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 9) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer)); memset(buffer, 0, sizeof(buffer));
@@ -306,10 +306,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 10) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 10) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer)); memset(buffer, 0, sizeof(buffer));
@@ -337,10 +337,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 11) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 11) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
memset(buffer, 0, sizeof(buffer)); memset(buffer, 0, sizeof(buffer));
@@ -362,31 +362,31 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session // expire session
sess = session_manager_get_expired_session(mgr, 11 + cfg.tcp_timeout_ms.time_wait); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 11 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif

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

@@ -18,11 +18,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -31,9 +31,9 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// C2S DATA Packet // C2S DATA Packet
@@ -43,10 +43,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -68,32 +68,32 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 1);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL); EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -107,11 +107,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// S2C SYNACK Packet // S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -120,9 +120,9 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// S2C DATA Packet // S2C DATA Packet
@@ -132,10 +132,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -157,32 +157,32 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 1);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL); EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif

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

@@ -18,11 +18,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -31,9 +31,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// C2S FIN Packet // C2S FIN Packet
@@ -43,10 +43,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
// S2C FIN Packet // S2C FIN Packet
printf("\n=> Packet Parse: TCP S2C FIN packet\n"); printf("\n=> Packet Parse: TCP S2C FIN packet\n");
@@ -55,10 +55,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -80,31 +80,31 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session // expire session
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.time_wait); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -118,11 +118,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -131,9 +131,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// C2S RST Packet // C2S RST Packet
@@ -149,10 +149,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -174,31 +174,31 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session // expire session
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.unverified_rst); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -212,11 +212,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -225,9 +225,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// S2C RST Packet // S2C RST Packet
@@ -243,10 +243,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -268,31 +268,31 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session // expire session
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.unverified_rst); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -305,11 +305,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
{ {
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -318,38 +318,38 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL); EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -363,11 +363,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -376,9 +376,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// S2C SYNACK Packet // S2C SYNACK Packet
@@ -388,10 +388,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -413,32 +413,32 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake) == NULL); EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -452,11 +452,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -465,9 +465,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// S2C SYNACK Packet // S2C SYNACK Packet
@@ -477,10 +477,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
// C2S ACK Packet // C2S ACK Packet
printf("\n=> Packet Parse: TCP C2S ACK packet\n"); printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -489,10 +489,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -514,32 +514,32 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data) == NULL); EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -553,11 +553,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -566,9 +566,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// C2S FIN Packet // C2S FIN Packet
@@ -578,10 +578,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -603,31 +603,31 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session // expire session
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.half_closed); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -641,11 +641,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -654,9 +654,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// S2C FIN Packet // S2C FIN Packet
@@ -666,10 +666,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -691,31 +691,31 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
// expire session // expire session
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.half_closed); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif

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

@@ -14,11 +14,11 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S REQ Packet // C2S REQ Packet
printf("\n=> Packet Parse: UDP C2S REQ packet\n"); printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -27,9 +27,9 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
@@ -57,10 +57,10 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -82,32 +82,32 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->udp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1);
EXPECT_TRUE(stat->udp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0);
EXPECT_TRUE(stat->udp_sess_active == 1); EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 1);
EXPECT_TRUE(stat->udp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data) == NULL); // active -> closing 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_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // closing -> closed sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->udp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 0);
EXPECT_TRUE(stat->udp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0);
EXPECT_TRUE(stat->udp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
EXPECT_TRUE(stat->udp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif

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

@@ -19,11 +19,11 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S REQ Packet // C2S REQ Packet
printf("\n=> Packet Parse: UDP C2S REQ packet\n"); printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -32,9 +32,9 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
@@ -57,32 +57,32 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->udp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1);
EXPECT_TRUE(stat->udp_sess_opening == 1); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 1);
EXPECT_TRUE(stat->udp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
EXPECT_TRUE(stat->udp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data) == NULL); // opening -> closing 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_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // closing -> closed sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->udp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 0);
EXPECT_TRUE(stat->udp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0);
EXPECT_TRUE(stat->udp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
EXPECT_TRUE(stat->udp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -97,11 +97,11 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
char buffer[1024] = {0}; char buffer[1024] = {0};
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
struct session_manager_stat *stat = NULL; struct session_manager_stat *sess_mgr_stat = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// S2C RESP Packet // S2C RESP Packet
printf("\n=> Packet Parse: UDP S2C RESP packet\n"); printf("\n=> Packet Parse: UDP S2C RESP packet\n");
@@ -110,9 +110,9 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_id(sess) != 0); EXPECT_TRUE(session_get_id(sess) != 0);
@@ -135,16 +135,16 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
session_print(sess); session_print(sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->udp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1);
EXPECT_TRUE(stat->udp_sess_opening == 1); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 1);
EXPECT_TRUE(stat->udp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
EXPECT_TRUE(stat->udp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data) == NULL); // opening -> closing 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_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // closing -> closed sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
@@ -152,17 +152,17 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
// check stat // check stat
stat = session_manager_stat(mgr); sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
EXPECT_TRUE(stat); EXPECT_TRUE(sess_mgr_stat);
EXPECT_TRUE(stat->udp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 0);
EXPECT_TRUE(stat->udp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0);
EXPECT_TRUE(stat->udp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
EXPECT_TRUE(stat->udp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif

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

@@ -12,10 +12,10 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
{ {
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -24,9 +24,9 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// C2S DATA Packet // C2S DATA Packet
@@ -36,22 +36,22 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL); EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif

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

@@ -12,10 +12,10 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
{ {
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// S2C SYNACK Packet // S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -24,22 +24,22 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake) == NULL); EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data); sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif

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

@@ -12,10 +12,10 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT)
{ {
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S SYN Packet // C2S SYN Packet
printf("\n=> Packet Parse: TCP C2S SYN packet\n"); printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -24,22 +24,22 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL); // opening -> closing 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_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data); // closing -> closed sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif

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

@@ -12,10 +12,10 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
{ {
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S REQ Packet // C2S REQ Packet
printf("\n=> Packet Parse: UDP C2S REQ packet\n"); printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -24,22 +24,22 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data) == NULL); // opening -> closing 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_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // closing -> closed sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif
@@ -48,10 +48,10 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
{ {
struct packet pkt; struct packet pkt;
struct session *sess = NULL; struct session *sess = NULL;
struct session_manager *mgr = NULL; struct session_manager_runtime *sess_mgr_rt = NULL;
mgr = session_manager_new(&cfg, 1); sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(sess_mgr_rt != NULL);
// C2S REQ Packet // C2S REQ Packet
printf("\n=> Packet Parse: UDP C2S REQ packet\n"); printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -60,9 +60,9 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL); EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
// new session // new session
sess = session_manager_new_session(mgr, &pkt, 1); sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// S2C RESP Packet // S2C RESP Packet
@@ -72,22 +72,22 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
printf("<= Packet Parse: done\n\n"); printf("<= Packet Parse: done\n\n");
// lookup session // lookup session
sess = session_manager_lookup_session_by_packet(mgr, &pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
// update session // update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0); EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
// expire session // expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data) == NULL); // active -> closing 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_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // closing -> closed sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
EXPECT_TRUE(sess); EXPECT_TRUE(sess);
EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
session_print(sess); session_print(sess);
// free session // free session
session_manager_free_session(mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
session_manager_free(mgr); session_manager_runtime_free(sess_mgr_rt);
} }
#endif #endif

42
infra/stellar_core.c
View File

@@ -42,7 +42,7 @@ struct stellar_thread
uint16_t idx; uint16_t idx;
uint64_t is_runing; uint64_t is_runing;
struct ip_reassembly *ip_reass; struct ip_reassembly *ip_reass;
struct session_manager *sess_mgr; struct session_manager_runtime *sess_mgr_rt;
struct stellar *st; struct stellar *st;
}; };
@@ -75,8 +75,6 @@ struct stellar
static __thread uint16_t __current_thread_idx = UINT16_MAX; static __thread uint16_t __current_thread_idx = UINT16_MAX;
uint64_t stellar_generate_session_id(uint64_t now_sec);
/****************************************************************************** /******************************************************************************
* Stellar Thread Main Loop * Stellar Thread Main Loop
******************************************************************************/ ******************************************************************************/
@@ -103,16 +101,16 @@ static void update_stat(struct session *sess, struct packet *pkt)
} }
} }
static inline void clean_session(struct session_manager *sess_mgr, uint64_t now_ms) static inline void clean_session(struct session_manager_runtime *sess_mgr_rt, uint64_t now_ms)
{ {
struct session *sess = NULL; struct session *sess = NULL;
struct session *cleaned_sess[RX_BURST_MAX * 16]; struct session *cleaned_sess[RX_BURST_MAX * 16];
uint64_t nr_sess_cleaned = session_manager_clean_session(sess_mgr, now_ms, cleaned_sess, sizeof(cleaned_sess) / sizeof(cleaned_sess[0])); uint64_t nr_sess_cleaned = session_manager_runtime_clean_session(sess_mgr_rt, now_ms, cleaned_sess, sizeof(cleaned_sess) / sizeof(cleaned_sess[0]));
for (uint64_t j = 0; j < nr_sess_cleaned; j++) for (uint64_t j = 0; j < nr_sess_cleaned; j++)
{ {
sess = cleaned_sess[j]; sess = cleaned_sess[j];
// session_exdata_runtime_free(session_get_user_data(sess)); // session_exdata_runtime_free(session_get_user_data(sess));
session_manager_free_session(sess_mgr, sess); session_manager_runtime_free_session(sess_mgr_rt, sess);
} }
} }
@@ -127,8 +125,8 @@ static void *worker_thread(void *arg)
struct session *sess = NULL; struct session *sess = NULL;
struct stellar_thread *thread = (struct stellar_thread *)arg; struct stellar_thread *thread = (struct stellar_thread *)arg;
struct ip_reassembly *ip_reass = thread->ip_reass; struct ip_reassembly *ip_reass = thread->ip_reass;
struct session_manager *sess_mgr = thread->sess_mgr; struct session_manager_runtime *sess_mgr_rt = thread->sess_mgr_rt;
struct session_manager_stat *sess_stat = session_manager_stat(sess_mgr); struct session_manager_stat *sess_stat = session_manager_runtime_get_stat(sess_mgr_rt);
struct stellar *st = thread->st; struct stellar *st = thread->st;
struct stellar_runtime *runtime = &st->runtime; struct stellar_runtime *runtime = &st->runtime;
struct packet_io *packet_io = runtime->packet_io; struct packet_io *packet_io = runtime->packet_io;
@@ -140,7 +138,7 @@ static void *worker_thread(void *arg)
struct thread_stat thr_stat = { struct thread_stat thr_stat = {
.pkt_io = packet_io_stat(packet_io, thread->idx), .pkt_io = packet_io_stat(packet_io, thread->idx),
.ip_reass = ip_reassembly_stat(ip_reass), .ip_reass = ip_reassembly_stat(ip_reass),
.sess_mgr = session_manager_stat(sess_mgr), .sess_mgr = session_manager_runtime_get_stat(sess_mgr_rt),
}; };
uint16_t thr_idx = thread->idx; uint16_t thr_idx = thread->idx;
@@ -189,6 +187,7 @@ static void *worker_thread(void *arg)
defraged_pkt = NULL; defraged_pkt = NULL;
pkt = &packets[i]; pkt = &packets[i];
// plugin_manager_on_packet_input(plug_mgr, pkt);
if (packet_is_fragment(pkt)) if (packet_is_fragment(pkt))
{ {
defraged_pkt = ip_reassembly_packet(ip_reass, pkt, now_ms); defraged_pkt = ip_reassembly_packet(ip_reass, pkt, now_ms);
@@ -199,13 +198,14 @@ static void *worker_thread(void *arg)
else else
{ {
pkt = defraged_pkt; pkt = defraged_pkt;
// plugin_manager_on_packet_input(plug_mgr, defraged_pkt);
} }
} }
sess = session_manager_lookup_session_by_packet(sess_mgr, pkt); sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, pkt);
if (sess == NULL) if (sess == NULL)
{ {
sess = session_manager_new_session(sess_mgr, pkt, now_ms); sess = session_manager_runtime_new_session(sess_mgr_rt, pkt, now_ms);
if (sess == NULL) if (sess == NULL)
{ {
goto fast_path; goto fast_path;
@@ -215,7 +215,7 @@ static void *worker_thread(void *arg)
} }
else else
{ {
if (session_manager_update_session(sess_mgr, sess, pkt, now_ms) == -1) if (session_manager_runtime_update_session(sess_mgr_rt, sess, pkt, now_ms) == -1)
{ {
goto fast_path; goto fast_path;
} }
@@ -224,9 +224,12 @@ static void *worker_thread(void *arg)
fast_path: fast_path:
if (pkt == defraged_pkt) if (pkt == defraged_pkt)
{ {
// plugin_manager_on_packet_output(plug_mgr, defraged_pkt);
// plugin_manager_on_packet_output(plug_mgr, &packets[i]);
} }
else else
{ {
// plugin_manager_on_packet_output(plug_mgr, pkt);
} }
if (sess) if (sess)
@@ -271,8 +274,9 @@ static void *worker_thread(void *arg)
} }
idle_tasks: idle_tasks:
clean_session(sess_mgr, now_ms); clean_session(sess_mgr_rt, now_ms);
ip_reassembly_expire(ip_reass, now_ms); ip_reassembly_expire(ip_reass, now_ms);
// plugin_manager_on_polling(plug_mgr);
stellar_stat_merge(runtime->stat, &thr_stat, thr_idx, now_ms); stellar_stat_merge(runtime->stat, &thr_stat, thr_idx, now_ms);
if (nr_pkt_received == 0) if (nr_pkt_received == 0)
@@ -285,7 +289,7 @@ static void *worker_thread(void *arg)
while (sess_stat->tcp_sess_used > 0 || sess_stat->udp_sess_used > 0) while (sess_stat->tcp_sess_used > 0 || sess_stat->udp_sess_used > 0)
{ {
now_ms = clock_get_real_time_ms(); now_ms = clock_get_real_time_ms();
clean_session(sess_mgr, now_ms); clean_session(sess_mgr_rt, now_ms);
usleep(1000); // 1ms usleep(1000); // 1ms
} }
@@ -318,8 +322,8 @@ static int stellar_thread_init(struct stellar *st)
thread->st = st; thread->st = st;
config->sess_mgr_cfg->session_id_seed = config->instance_id << 8 | i; config->sess_mgr_cfg->session_id_seed = config->instance_id << 8 | i;
thread->sess_mgr = session_manager_new(config->sess_mgr_cfg, now_ms); thread->sess_mgr_rt = session_manager_runtime_new(config->sess_mgr_cfg, now_ms);
if (thread->sess_mgr == NULL) if (thread->sess_mgr_rt == NULL)
{ {
CORE_LOG_ERROR("unable to create session manager"); CORE_LOG_ERROR("unable to create session manager");
return -1; return -1;
@@ -366,7 +370,7 @@ static void stellar_thread_join(struct stellar *st)
pthread_join(thread->tid, NULL); pthread_join(thread->tid, NULL);
ip_reassembly_free(thread->ip_reass); ip_reassembly_free(thread->ip_reass);
session_manager_free(thread->sess_mgr); session_manager_runtime_free(thread->sess_mgr_rt);
} }
CORE_LOG_FATAL("all worker thread exited"); CORE_LOG_FATAL("all worker thread exited");
} }
@@ -573,8 +577,8 @@ void stellar_send_build_packet(struct stellar *st, struct packet *pkt)
{ {
uint16_t thr_idx = stellar_module_manager_get_thread_id(st->runtime.mod_mgr); uint16_t thr_idx = stellar_module_manager_get_thread_id(st->runtime.mod_mgr);
struct packet_io *packet_io = st->runtime.packet_io; struct packet_io *packet_io = st->runtime.packet_io;
struct session_manager *sess_mgr = st->runtime.threads[thr_idx].sess_mgr; struct session_manager_runtime *sess_mgr_rt = st->runtime.threads[thr_idx].sess_mgr_rt;
session_manager_record_duplicated_packet(sess_mgr, pkt); session_manager_runtime_record_duplicated_packet(sess_mgr_rt, pkt);
if (packet_get_origin_ctx(pkt)) if (packet_get_origin_ctx(pkt))
{ {