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

enhance: rename session manager stat iterm name

Browse Source
This commit is contained in:
luwenpeng
2024-08-14 11:25:04 +08:00
parent 7e377952a2
commit e8299dd77c
16 changed files with 484 additions and 484 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
src/session/session_manager.cpp
View File

@@ -49,52 +49,52 @@ struct session_manager
* Session Manager Stat
******************************************************************************/
#define SESS_MGR_STAT_INC(stat, state, proto) \
{ \
switch ((state)) \
{ \
case SESSION_STATE_OPENING: \
(stat)->curr_nr_##proto##_sess_opening++; \
break; \
case SESSION_STATE_ACTIVE: \
(stat)->curr_nr_##proto##_sess_active++; \
break; \
case SESSION_STATE_CLOSING: \
(stat)->curr_nr_##proto##_sess_closing++; \
break; \
case SESSION_STATE_DISCARD: \
(stat)->curr_nr_##proto##_sess_discard++; \
break; \
case SESSION_STATE_CLOSED: \
(stat)->curr_nr_##proto##_sess_closed++; \
break; \
default: \
break; \
} \
#define SESS_MGR_STAT_INC(stat, state, proto) \
{ \
switch ((state)) \
{ \
case SESSION_STATE_OPENING: \
(stat)->curr_##proto##_sess_opening++; \
break; \
case SESSION_STATE_ACTIVE: \
(stat)->curr_##proto##_sess_active++; \
break; \
case SESSION_STATE_CLOSING: \
(stat)->curr_##proto##_sess_closing++; \
break; \
case SESSION_STATE_DISCARD: \
(stat)->curr_##proto##_sess_discard++; \
break; \
case SESSION_STATE_CLOSED: \
(stat)->curr_##proto##_sess_closed++; \
break; \
default: \
break; \
} \
}
#define SESS_MGR_STAT_DEC(stat, state, proto) \
{ \
switch ((state)) \
{ \
case SESSION_STATE_OPENING: \
(stat)->curr_nr_##proto##_sess_opening--; \
break; \
case SESSION_STATE_ACTIVE: \
(stat)->curr_nr_##proto##_sess_active--; \
break; \
case SESSION_STATE_CLOSING: \
(stat)->curr_nr_##proto##_sess_closing--; \
break; \
case SESSION_STATE_DISCARD: \
(stat)->curr_nr_##proto##_sess_discard--; \
break; \
case SESSION_STATE_CLOSED: \
(stat)->curr_nr_##proto##_sess_closed--; \
break; \
default: \
break; \
} \
#define SESS_MGR_STAT_DEC(stat, state, proto) \
{ \
switch ((state)) \
{ \
case SESSION_STATE_OPENING: \
(stat)->curr_##proto##_sess_opening--; \
break; \
case SESSION_STATE_ACTIVE: \
(stat)->curr_##proto##_sess_active--; \
break; \
case SESSION_STATE_CLOSING: \
(stat)->curr_##proto##_sess_closing--; \
break; \
case SESSION_STATE_DISCARD: \
(stat)->curr_##proto##_sess_discard--; \
break; \
case SESSION_STATE_CLOSED: \
(stat)->curr_##proto##_sess_closed--; \
break; \
default: \
break; \
} \
}
#define SESS_MGR_STAT_UPDATE(stat, curr, next, proto) \
@@ -250,7 +250,7 @@ static void tcp_clean(struct session_manager *mgr, struct session *sess)
{
session_inc_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_RELEASED, 1);
session_inc_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_RELEASED, seg->len);
mgr->stat.nr_tcp_seg_released++;
mgr->stat.tcp_seg_released++;
tcp_segment_free(seg);
}
tcp_reassembly_free(c2s_ssembler);
@@ -261,7 +261,7 @@ static void tcp_clean(struct session_manager *mgr, struct session *sess)
{
session_inc_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_RELEASED, 1);
session_inc_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_RELEASED, seg->len);
mgr->stat.nr_tcp_seg_released++;
mgr->stat.tcp_seg_released++;
tcp_segment_free(seg);
}
tcp_reassembly_free(s2c_ssembler);
@@ -315,11 +315,11 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
{
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RECEIVED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RECEIVED, len);
mgr->stat.nr_tcp_seg_received++;
mgr->stat.tcp_seg_received++;
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_INORDER, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_INORDER, len);
mgr->stat.nr_tcp_seg_inorder++;
mgr->stat.tcp_seg_inorder++;
half->in_order.data = tcp_layer->pld_ptr;
half->in_order.len = len;
@@ -339,11 +339,11 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
{
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_EXPIRED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_EXPIRED, seg->len);
mgr->stat.nr_tcp_seg_expired++;
mgr->stat.tcp_seg_expired++;
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RELEASED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RELEASED, seg->len);
mgr->stat.nr_tcp_seg_released++;
mgr->stat.tcp_seg_released++;
tcp_segment_free(seg);
}
@@ -352,7 +352,7 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
{
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RECEIVED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RECEIVED, len);
mgr->stat.nr_tcp_seg_received++;
mgr->stat.tcp_seg_received++;
uint32_t rcv_nxt = tcp_reassembly_get_recv_next(half->assembler);
// in order
@@ -360,7 +360,7 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
{
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_INORDER, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_INORDER, len);
mgr->stat.nr_tcp_seg_inorder++;
mgr->stat.tcp_seg_inorder++;
half->in_order.data = tcp_layer->pld_ptr;
half->in_order.len = len;
@@ -372,7 +372,7 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
{
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RETRANSMIT, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RETRANSMIT, len);
mgr->stat.nr_tcp_seg_retransmit++;
mgr->stat.tcp_seg_retransmit++;
}
else if ((seg = tcp_segment_new(half->seq, tcp_layer->pld_ptr, len)))
{
@@ -381,28 +381,28 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
case -2:
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RETRANSMIT, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RETRANSMIT, len);
mgr->stat.nr_tcp_seg_retransmit++;
mgr->stat.tcp_seg_retransmit++;
tcp_segment_free(seg);
break;
case -1:
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_NOSPACE, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_NOSPACE, len);
mgr->stat.nr_tcp_seg_no_space++;
mgr->stat.tcp_seg_no_space++;
tcp_segment_free(seg);
break;
case 0:
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_BUFFERED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_BUFFERED, len);
mgr->stat.nr_tcp_seg_buffered++;
mgr->stat.tcp_seg_buffered++;
break;
case 1:
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_OVERLAP, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_OVERLAP, len);
mgr->stat.nr_tcp_seg_overlap++;
mgr->stat.tcp_seg_overlap++;
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_BUFFERED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_BUFFERED, len);
mgr->stat.nr_tcp_seg_buffered++;
mgr->stat.tcp_seg_buffered++;
break;
default:
assert(0);
@@ -413,7 +413,7 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
{
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_NOSPACE, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_NOSPACE, len);
mgr->stat.nr_tcp_seg_no_space++;
mgr->stat.tcp_seg_no_space++;
}
}
}
@@ -459,9 +459,9 @@ static enum flow_direction identify_direction_by_history(const struct session *s
// on new session
static int tcp_overload_bypass(struct session_manager *mgr, const struct tuple6 *key)
{
if (key->ip_proto == IPPROTO_TCP && mgr->stat.curr_nr_tcp_sess_used >= mgr->opts.max_tcp_session_num)
if (key->ip_proto == IPPROTO_TCP && mgr->stat.curr_tcp_sess_used >= mgr->opts.max_tcp_session_num)
{
mgr->stat.nr_tcp_pkts_nospace_bypass++;
mgr->stat.tcp_pkts_nospace_bypass++;
return 1;
}
return 0;
@@ -469,9 +469,9 @@ static int tcp_overload_bypass(struct session_manager *mgr, const struct tuple6
static int udp_overload_bypass(struct session_manager *mgr, const struct tuple6 *key)
{
if (key->ip_proto == IPPROTO_UDP && mgr->stat.curr_nr_udp_sess_used >= mgr->opts.max_udp_session_num)
if (key->ip_proto == IPPROTO_UDP && mgr->stat.curr_udp_sess_used >= mgr->opts.max_udp_session_num)
{
mgr->stat.nr_udp_pkts_nospace_bypass++;
mgr->stat.udp_pkts_nospace_bypass++;
return 1;
}
return 0;
@@ -481,7 +481,7 @@ static int evicted_session_bypass(struct session_manager *mgr, const struct tupl
{
if (mgr->opts.evicted_session_filter_enable && evicted_session_filter_lookup(mgr->evicte_sess_filter, key, mgr->now_ms))
{
mgr->stat.nr_udp_pkts_evctd_bypass++;
mgr->stat.udp_pkts_evctd_bypass++;
return 1;
}
@@ -506,10 +506,10 @@ static int duplicated_packet_bypass(struct session_manager *mgr, struct session
switch (session_get_type(sess))
{
case SESSION_TYPE_TCP:
mgr->stat.nr_tcp_pkts_duped_bypass++;
mgr->stat.tcp_pkts_duped_bypass++;
break;
case SESSION_TYPE_UDP:
mgr->stat.nr_udp_pkts_duped_bypass++;
mgr->stat.udp_pkts_duped_bypass++;
break;
default:
assert(0);
@@ -632,7 +632,7 @@ static void session_manager_evicte_session(struct session_manager *mgr, struct s
SESSION_LOG_DEBUG("evicte tcp old session: %lu", session_get_id(sess));
session_table_del(mgr->tcp_sess_table, sess);
SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, tcp);
mgr->stat.nr_tcp_sess_evicted++;
mgr->stat.tcp_sess_evicted++;
break;
case SESSION_TYPE_UDP:
SESSION_LOG_DEBUG("evicte udp old session: %lu", session_get_id(sess));
@@ -642,7 +642,7 @@ static void session_manager_evicte_session(struct session_manager *mgr, struct s
evicted_session_filter_add(mgr->evicte_sess_filter, session_get_tuple6(sess), mgr->now_ms);
}
SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, udp);
mgr->stat.nr_udp_sess_evicted++;
mgr->stat.udp_sess_evicted++;
break;
default:
assert(0);
@@ -689,12 +689,12 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
uint8_t flags = tcp_hdr_get_flags(hdr);
if (!(flags & TH_SYN))
{
mgr->stat.nr_tcp_pkts_nosess_bypass++;
mgr->stat.tcp_pkts_nosess_bypass++;
return NULL;
}
// tcp table full evict old session
if (mgr->opts.tcp_overload_evict_old_sess && mgr->stat.curr_nr_tcp_sess_used >= mgr->opts.max_tcp_session_num - EVICTE_SESSION_BURST)
if (mgr->opts.tcp_overload_evict_old_sess && mgr->stat.curr_tcp_sess_used >= mgr->opts.max_tcp_session_num - EVICTE_SESSION_BURST)
{
struct session *evic_sess = session_table_find_lru(mgr->tcp_sess_table);
session_manager_evicte_session(mgr, evic_sess, LRU_EVICT);
@@ -733,8 +733,8 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
}
SESS_MGR_STAT_INC(&mgr->stat, next_state, tcp);
mgr->stat.curr_nr_tcp_sess_used++;
mgr->stat.total_nr_tcp_sess_used++;
mgr->stat.curr_tcp_sess_used++;
mgr->stat.total_tcp_sess_used++;
return sess;
}
@@ -742,7 +742,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
static struct session *session_manager_new_udp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key)
{
// udp table full evict old session
if (mgr->opts.udp_overload_evict_old_sess && mgr->stat.curr_nr_udp_sess_used >= mgr->opts.max_udp_session_num - EVICTE_SESSION_BURST)
if (mgr->opts.udp_overload_evict_old_sess && mgr->stat.curr_udp_sess_used >= mgr->opts.max_udp_session_num - EVICTE_SESSION_BURST)
{
struct session *evic_sess = session_table_find_lru(mgr->udp_sess_table);
session_manager_evicte_session(mgr, evic_sess, LRU_EVICT);
@@ -767,8 +767,8 @@ static struct session *session_manager_new_udp_session(struct session_manager *m
session_table_add(mgr->udp_sess_table, sess);
SESS_MGR_STAT_INC(&mgr->stat, next_state, udp);
mgr->stat.curr_nr_udp_sess_used++;
mgr->stat.total_nr_udp_sess_used++;
mgr->stat.curr_udp_sess_used++;
mgr->stat.total_udp_sess_used++;
return sess;
}
@@ -1033,7 +1033,7 @@ void session_manager_free_session(struct session_manager *mgr, struct session *s
session_table_del(mgr->tcp_sess_table, sess);
}
SESS_MGR_STAT_DEC(&mgr->stat, session_get_current_state(sess), tcp);
mgr->stat.curr_nr_tcp_sess_used--;
mgr->stat.curr_tcp_sess_used--;
break;
case SESSION_TYPE_UDP:
if (session_table_find_sessid(mgr->udp_sess_table, session_get_id(sess), 0) == sess)
@@ -1041,7 +1041,7 @@ void session_manager_free_session(struct session_manager *mgr, struct session *s
session_table_del(mgr->udp_sess_table, sess);
}
SESS_MGR_STAT_DEC(&mgr->stat, session_get_current_state(sess), udp);
mgr->stat.curr_nr_udp_sess_used--;
mgr->stat.curr_udp_sess_used--;
break;
default:
assert(0);

62
src/session/session_manager.h
View File

@@ -48,45 +48,45 @@ struct session_manager_options
struct session_manager_stat
{
// TCP session
uint64_t total_nr_tcp_sess_used;
uint64_t curr_nr_tcp_sess_used;
uint64_t curr_nr_tcp_sess_opening;
uint64_t curr_nr_tcp_sess_active;
uint64_t curr_nr_tcp_sess_closing;
uint64_t curr_nr_tcp_sess_discard;
uint64_t curr_nr_tcp_sess_closed;
uint64_t total_tcp_sess_used;
uint64_t curr_tcp_sess_used;
uint64_t curr_tcp_sess_opening;
uint64_t curr_tcp_sess_active;
uint64_t curr_tcp_sess_closing;
uint64_t curr_tcp_sess_discard;
uint64_t curr_tcp_sess_closed;
// UDP session
uint64_t total_nr_udp_sess_used;
uint64_t curr_nr_udp_sess_used;
uint64_t curr_nr_udp_sess_opening;
uint64_t curr_nr_udp_sess_active;
uint64_t curr_nr_udp_sess_closing;
uint64_t curr_nr_udp_sess_discard;
uint64_t curr_nr_udp_sess_closed;
uint64_t total_udp_sess_used;
uint64_t curr_udp_sess_used;
uint64_t curr_udp_sess_opening;
uint64_t curr_udp_sess_active;
uint64_t curr_udp_sess_closing;
uint64_t curr_udp_sess_discard;
uint64_t curr_udp_sess_closed;
// Evicted session
uint64_t nr_tcp_sess_evicted; // sum
uint64_t nr_udp_sess_evicted; // sum
uint64_t tcp_sess_evicted; // sum
uint64_t udp_sess_evicted; // sum
// Packet
uint64_t nr_udp_pkts_nospace_bypass; // sum
uint64_t nr_tcp_pkts_nospace_bypass; // sum
uint64_t nr_tcp_pkts_nosess_bypass; // sum
uint64_t nr_tcp_pkts_duped_bypass; // sum
uint64_t nr_udp_pkts_duped_bypass; // sum
uint64_t nr_udp_pkts_evctd_bypass; // sum
uint64_t udp_pkts_nospace_bypass; // sum
uint64_t tcp_pkts_nospace_bypass; // sum
uint64_t tcp_pkts_nosess_bypass; // sum
uint64_t tcp_pkts_duped_bypass; // sum
uint64_t udp_pkts_duped_bypass; // sum
uint64_t udp_pkts_evctd_bypass; // sum
// TCP segments
uint64_t nr_tcp_seg_received; // sum
uint64_t nr_tcp_seg_expired; // sum
uint64_t nr_tcp_seg_retransmit; // sum
uint64_t nr_tcp_seg_overlap; // sum
uint64_t nr_tcp_seg_no_space; // sum
uint64_t nr_tcp_seg_inorder; // sum
uint64_t nr_tcp_seg_reorded; // sum
uint64_t nr_tcp_seg_buffered; // sum
uint64_t nr_tcp_seg_released; // sum
uint64_t tcp_seg_received; // sum
uint64_t tcp_seg_expired; // sum
uint64_t tcp_seg_retransmit; // sum
uint64_t tcp_seg_overlap; // sum
uint64_t tcp_seg_no_space; // sum
uint64_t tcp_seg_inorder; // sum
uint64_t tcp_seg_reorded; // sum
uint64_t tcp_seg_buffered; // sum
uint64_t tcp_seg_released; // sum
};
struct session_manager;

4
src/session/session_utils.cpp
View File

@@ -252,7 +252,7 @@ struct tcp_segment *session_get_tcp_segment(struct session *sess)
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_REORDERED, seg->len);
// TODO
sess->mgr_stat->nr_tcp_seg_reorded++;
sess->mgr_stat->tcp_seg_reorded++;
}
return seg;
}
@@ -278,7 +278,7 @@ void session_free_tcp_segment(struct session *sess, struct tcp_segment *seg)
{
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RELEASED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RELEASED, seg->len);
sess->mgr_stat->nr_tcp_seg_released++;
sess->mgr_stat->tcp_seg_released++;
tcp_segment_free(seg);
}

16
src/session/test/gtest_case_tcp_fast_open.cpp
View File

@@ -392,10 +392,10 @@ TEST(CASE, TCP_FAST_OPEN)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_init_timeout) == NULL); // opening -> closing
@@ -410,10 +410,10 @@ TEST(CASE, TCP_FAST_OPEN)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}

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

@@ -81,7 +81,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->nr_tcp_pkts_duped_bypass == 0);
EXPECT_TRUE(stat->tcp_pkts_duped_bypass == 0);
// C2S SYN dup Packet
printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
@@ -97,7 +97,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->nr_tcp_pkts_duped_bypass == 1);
EXPECT_TRUE(stat->tcp_pkts_duped_bypass == 1);
// C2S SYN retransmission Packet
printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
@@ -116,7 +116,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->nr_tcp_pkts_duped_bypass == 1);
EXPECT_TRUE(stat->tcp_pkts_duped_bypass == 1);
session_manager_free(mgr);
}
@@ -147,7 +147,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->nr_tcp_pkts_duped_bypass == 0);
EXPECT_TRUE(stat->tcp_pkts_duped_bypass == 0);
// S2C SYNACK dup Packet
printf("\n=> Packet Parse: TCP S2C SYNACK dup packet\n");
@@ -163,7 +163,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->nr_tcp_pkts_duped_bypass == 1);
EXPECT_TRUE(stat->tcp_pkts_duped_bypass == 1);
// S2C SYNACK retransmission Packet
printf("\n=> Packet Parse: TCP S2C SYNACK retransmission packet\n");
@@ -182,7 +182,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->nr_tcp_pkts_duped_bypass == 1);
EXPECT_TRUE(stat->tcp_pkts_duped_bypass == 1);
session_manager_free(mgr);
}
@@ -214,7 +214,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->nr_tcp_pkts_duped_bypass == 0);
EXPECT_TRUE(stat->tcp_pkts_duped_bypass == 0);
// C2S SYN retransmission Packet
printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
@@ -232,7 +232,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->nr_tcp_pkts_duped_bypass == 0);
EXPECT_TRUE(stat->tcp_pkts_duped_bypass == 0);
// C2S SYN retransmission Packet
printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
@@ -250,7 +250,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->nr_tcp_pkts_duped_bypass == 0);
EXPECT_TRUE(stat->tcp_pkts_duped_bypass == 0);
// C2S SYN dup Packet
printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
@@ -266,7 +266,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->nr_tcp_pkts_duped_bypass == 0);
EXPECT_TRUE(stat->tcp_pkts_duped_bypass == 0);
session_manager_free(mgr);
}
@@ -300,7 +300,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->nr_tcp_pkts_duped_bypass == 0);
EXPECT_TRUE(stat->tcp_pkts_duped_bypass == 0);
// C2S SYN dup Packet
printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
@@ -316,7 +316,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->nr_tcp_pkts_duped_bypass == 0);
EXPECT_TRUE(stat->tcp_pkts_duped_bypass == 0);
session_manager_free(mgr);
}
@@ -350,7 +350,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->nr_tcp_pkts_duped_bypass == 0);
EXPECT_TRUE(stat->tcp_pkts_duped_bypass == 0);
// S2C SYNACK dup Packet
printf("\n=> Packet Parse: TCP S2C SYNACK dup packet\n");
@@ -366,7 +366,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->nr_tcp_pkts_duped_bypass == 0);
EXPECT_TRUE(stat->tcp_pkts_duped_bypass == 0);
session_manager_free(mgr);
}

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

@@ -82,14 +82,14 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
printf("=> Session Manager: after add %lu new sessions\n", opts.max_tcp_session_num);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == opts.max_tcp_session_num);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closed == RX_BURST_MAX); // have evicted, have't free
EXPECT_TRUE(stat->nr_tcp_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->nr_tcp_pkts_nospace_bypass == 0);
EXPECT_TRUE(stat->nr_tcp_pkts_nosess_bypass == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == opts.max_tcp_session_num);
EXPECT_TRUE(stat->curr_tcp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closed == RX_BURST_MAX); // have evicted, have't free
EXPECT_TRUE(stat->tcp_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->tcp_pkts_nospace_bypass == 0);
EXPECT_TRUE(stat->tcp_pkts_nosess_bypass == 0);
session_manager_free(mgr);
}
@@ -123,14 +123,14 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
printf("=> Session Manager: after add %lu new sessions\n", opts.max_tcp_session_num);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == opts.max_tcp_session_num);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == opts.max_tcp_session_num);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closed == 0);
EXPECT_TRUE(stat->nr_tcp_sess_evicted == 0);
EXPECT_TRUE(stat->nr_tcp_pkts_nospace_bypass == 0);
EXPECT_TRUE(stat->nr_tcp_pkts_nosess_bypass == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == opts.max_tcp_session_num);
EXPECT_TRUE(stat->curr_tcp_sess_opening == opts.max_tcp_session_num);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closed == 0);
EXPECT_TRUE(stat->tcp_sess_evicted == 0);
EXPECT_TRUE(stat->tcp_pkts_nospace_bypass == 0);
EXPECT_TRUE(stat->tcp_pkts_nosess_bypass == 0);
// table full, evict new session
for (uint32_t i = 0; i < RX_BURST_MAX; i++)
@@ -142,14 +142,14 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
printf("=> Session Manager: after evicte new session\n");
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == opts.max_tcp_session_num);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == opts.max_tcp_session_num);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closed == 0);
EXPECT_TRUE(stat->nr_tcp_sess_evicted == 0);
EXPECT_TRUE(stat->nr_tcp_pkts_nospace_bypass == RX_BURST_MAX);
EXPECT_TRUE(stat->nr_tcp_pkts_nosess_bypass == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == opts.max_tcp_session_num);
EXPECT_TRUE(stat->curr_tcp_sess_opening == opts.max_tcp_session_num);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closed == 0);
EXPECT_TRUE(stat->tcp_sess_evicted == 0);
EXPECT_TRUE(stat->tcp_pkts_nospace_bypass == RX_BURST_MAX);
EXPECT_TRUE(stat->tcp_pkts_nosess_bypass == 0);
session_manager_free(mgr);
}

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

@@ -83,14 +83,14 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
printf("=> Session Manager: after add %lu new sessions\n", opts.max_udp_session_num);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_udp_sess_used == opts.max_udp_session_num);
EXPECT_TRUE(stat->curr_nr_udp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->curr_nr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_closing == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_closed == RX_BURST_MAX); // have evicted, have't free
EXPECT_TRUE(stat->nr_udp_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->nr_udp_pkts_nospace_bypass == 0);
EXPECT_TRUE(stat->nr_udp_pkts_evctd_bypass == 0);
EXPECT_TRUE(stat->curr_udp_sess_used == opts.max_udp_session_num);
EXPECT_TRUE(stat->curr_udp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->curr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
EXPECT_TRUE(stat->curr_udp_sess_closed == RX_BURST_MAX); // have evicted, have't free
EXPECT_TRUE(stat->udp_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_pkts_nospace_bypass == 0);
EXPECT_TRUE(stat->udp_pkts_evctd_bypass == 0);
// evicted session
while (1)
@@ -115,14 +115,14 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
printf("=> Session Manager: after readd %d evicted sessions\n", RX_BURST_MAX);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_udp_sess_used == RX_BURST_MAX);
EXPECT_TRUE(stat->curr_nr_udp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->curr_nr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_closing == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_closed == 0);
EXPECT_TRUE(stat->nr_udp_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->nr_udp_pkts_nospace_bypass == 0);
EXPECT_TRUE(stat->nr_udp_pkts_evctd_bypass == RX_BURST_MAX);
EXPECT_TRUE(stat->curr_udp_sess_used == RX_BURST_MAX);
EXPECT_TRUE(stat->curr_udp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->curr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
EXPECT_TRUE(stat->curr_udp_sess_closed == 0);
EXPECT_TRUE(stat->udp_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_pkts_nospace_bypass == 0);
EXPECT_TRUE(stat->udp_pkts_evctd_bypass == RX_BURST_MAX);
// evicted session timeout
packet_set_ip_src_addr(&pkt, 0);
@@ -131,14 +131,14 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
printf("=> Session Manager: after evicted session timeout\n");
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_udp_sess_used == RX_BURST_MAX + 1);
EXPECT_TRUE(stat->curr_nr_udp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->curr_nr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_closing == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_closed == 1); // have evicted, have't free
EXPECT_TRUE(stat->nr_udp_sess_evicted == RX_BURST_MAX + 1);
EXPECT_TRUE(stat->nr_udp_pkts_nospace_bypass == 0);
EXPECT_TRUE(stat->nr_udp_pkts_evctd_bypass == RX_BURST_MAX);
EXPECT_TRUE(stat->curr_udp_sess_used == RX_BURST_MAX + 1);
EXPECT_TRUE(stat->curr_udp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->curr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
EXPECT_TRUE(stat->curr_udp_sess_closed == 1); // have evicted, have't free
EXPECT_TRUE(stat->udp_sess_evicted == RX_BURST_MAX + 1);
EXPECT_TRUE(stat->udp_pkts_nospace_bypass == 0);
EXPECT_TRUE(stat->udp_pkts_evctd_bypass == RX_BURST_MAX);
session_manager_free(mgr);
}
@@ -172,14 +172,14 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
printf("=> Session Manager: after add %lu new sessions\n", opts.max_udp_session_num);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_udp_sess_used == opts.max_udp_session_num);
EXPECT_TRUE(stat->curr_nr_udp_sess_opening == opts.max_udp_session_num);
EXPECT_TRUE(stat->curr_nr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_closing == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_closed == 0);
EXPECT_TRUE(stat->nr_udp_sess_evicted == 0);
EXPECT_TRUE(stat->nr_udp_pkts_nospace_bypass == 0);
EXPECT_TRUE(stat->nr_udp_pkts_evctd_bypass == 0);
EXPECT_TRUE(stat->curr_udp_sess_used == opts.max_udp_session_num);
EXPECT_TRUE(stat->curr_udp_sess_opening == opts.max_udp_session_num);
EXPECT_TRUE(stat->curr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
EXPECT_TRUE(stat->curr_udp_sess_closed == 0);
EXPECT_TRUE(stat->udp_sess_evicted == 0);
EXPECT_TRUE(stat->udp_pkts_nospace_bypass == 0);
EXPECT_TRUE(stat->udp_pkts_evctd_bypass == 0);
// evicted session
EXPECT_TRUE(session_manager_get_evicted_session(mgr) == NULL);
@@ -194,14 +194,14 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
printf("=> Session Manager: after readd %d evicted session\n", RX_BURST_MAX);
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_udp_sess_used == opts.max_udp_session_num);
EXPECT_TRUE(stat->curr_nr_udp_sess_opening == opts.max_udp_session_num);
EXPECT_TRUE(stat->curr_nr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_closing == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_closed == 0);
EXPECT_TRUE(stat->nr_udp_sess_evicted == 0);
EXPECT_TRUE(stat->nr_udp_pkts_nospace_bypass == RX_BURST_MAX);
EXPECT_TRUE(stat->nr_udp_pkts_evctd_bypass == 0);
EXPECT_TRUE(stat->curr_udp_sess_used == opts.max_udp_session_num);
EXPECT_TRUE(stat->curr_udp_sess_opening == opts.max_udp_session_num);
EXPECT_TRUE(stat->curr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
EXPECT_TRUE(stat->curr_udp_sess_closed == 0);
EXPECT_TRUE(stat->udp_sess_evicted == 0);
EXPECT_TRUE(stat->udp_pkts_nospace_bypass == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_pkts_evctd_bypass == 0);
session_manager_free(mgr);
}

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

@@ -146,10 +146,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 1);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_time_wait_timeout);
@@ -163,10 +163,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -233,10 +233,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 1);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_unverified_rst_timeout);
@@ -250,10 +250,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -320,10 +320,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 1);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_unverified_rst_timeout);
@@ -337,10 +337,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -366,10 +366,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 1);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -384,10 +384,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -447,10 +447,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 1);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_half_closed_timeout);
@@ -464,10 +464,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -527,10 +527,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 1);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_half_closed_timeout);
@@ -544,10 +544,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}

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

@@ -102,10 +102,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_init_timeout) == NULL); // opening -> closing
@@ -120,10 +120,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -180,10 +180,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_handshake_timeout) == NULL);
@@ -198,10 +198,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -270,10 +270,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_handshake_timeout) == NULL);
@@ -288,10 +288,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -372,10 +372,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + opts.tcp_data_timeout) == NULL);
@@ -390,10 +390,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -469,10 +469,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_init_timeout) == NULL);
@@ -487,10 +487,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -567,10 +567,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_handshake_timeout) == NULL);
@@ -585,10 +585,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -657,10 +657,10 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -675,10 +675,10 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -747,10 +747,10 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -765,10 +765,10 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}

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

@@ -417,10 +417,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 1);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 11 + opts.tcp_time_wait_timeout);
@@ -434,10 +434,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}

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

@@ -113,10 +113,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 1);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -131,10 +131,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -203,10 +203,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 1);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -221,10 +221,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}

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

@@ -126,10 +126,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 1);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_time_wait_timeout);
@@ -143,10 +143,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -222,10 +222,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 1);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_unverified_rst_timeout);
@@ -239,10 +239,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -318,10 +318,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 1);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_unverified_rst_timeout);
@@ -335,10 +335,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -374,10 +374,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_init_timeout) == NULL);
@@ -392,10 +392,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -464,10 +464,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_handshake_timeout) == NULL);
@@ -482,10 +482,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -566,10 +566,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + opts.tcp_data_timeout) == NULL);
@@ -584,10 +584,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -656,10 +656,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 1);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_half_closed_timeout);
@@ -673,10 +673,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -745,10 +745,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 1);
EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_half_closed_timeout);
@@ -762,10 +762,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
session_manager_free(mgr);
}

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

@@ -128,10 +128,10 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_udp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_udp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_active == 1);
EXPECT_TRUE(stat->curr_nr_udp_sess_closing == 0);
EXPECT_TRUE(stat->curr_udp_sess_used == 1);
EXPECT_TRUE(stat->curr_udp_sess_opening == 0);
EXPECT_TRUE(stat->curr_udp_sess_active == 1);
EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.udp_data_timeout) == NULL); // active -> closing
@@ -146,10 +146,10 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_udp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_closing == 0);
EXPECT_TRUE(stat->curr_udp_sess_used == 0);
EXPECT_TRUE(stat->curr_udp_sess_opening == 0);
EXPECT_TRUE(stat->curr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
session_manager_free(mgr);
}

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

@@ -102,10 +102,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_udp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_udp_sess_opening == 1);
EXPECT_TRUE(stat->curr_nr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_closing == 0);
EXPECT_TRUE(stat->curr_udp_sess_used == 1);
EXPECT_TRUE(stat->curr_udp_sess_opening == 1);
EXPECT_TRUE(stat->curr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.udp_data_timeout) == NULL); // opening -> closing
@@ -120,10 +120,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_udp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_closing == 0);
EXPECT_TRUE(stat->curr_udp_sess_used == 0);
EXPECT_TRUE(stat->curr_udp_sess_opening == 0);
EXPECT_TRUE(stat->curr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -181,10 +181,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_udp_sess_used == 1);
EXPECT_TRUE(stat->curr_nr_udp_sess_opening == 1);
EXPECT_TRUE(stat->curr_nr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_closing == 0);
EXPECT_TRUE(stat->curr_udp_sess_used == 1);
EXPECT_TRUE(stat->curr_udp_sess_opening == 1);
EXPECT_TRUE(stat->curr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.udp_data_timeout) == NULL); // opening -> closing
@@ -201,10 +201,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
// check stat
stat = session_manager_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->curr_nr_udp_sess_used == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_opening == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_nr_udp_sess_closing == 0);
EXPECT_TRUE(stat->curr_udp_sess_used == 0);
EXPECT_TRUE(stat->curr_udp_sess_opening == 0);
EXPECT_TRUE(stat->curr_udp_sess_active == 0);
EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
session_manager_free(mgr);
}

4
src/stellar/stellar_core.cpp
View File

@@ -355,12 +355,12 @@ static int all_session_have_freed(struct stellar_runtime *runtime, struct stella
struct session_manager *sess_mgr = runtime->threads[i].sess_mgr;
struct session_manager_stat *sess_stat = session_manager_stat(sess_mgr);
if (ATOMIC_READ(&sess_stat->curr_nr_tcp_sess_used) != 0)
if (ATOMIC_READ(&sess_stat->curr_tcp_sess_used) != 0)
{
return 0;
}
if (ATOMIC_READ(&sess_stat->curr_nr_udp_sess_used) != 0)
if (ATOMIC_READ(&sess_stat->curr_udp_sess_used) != 0)
{
return 0;
}

124
src/stellar/stellar_stat.cpp
View File

@@ -53,37 +53,37 @@ static inline uint64_t get_ip6_flow_fail_many_frag(struct thread_stat *thr_stat)
static inline uint64_t get_ip6_flow_fail_invalid_length(struct thread_stat *thr_stat) { return thr_stat->ip_reassembly->ip6_flow_fail_invalid_length; }
static inline uint64_t get_ip6_flow_bypass_dup_fist_frag(struct thread_stat *thr_stat) { return thr_stat->ip_reassembly->ip6_flow_bypass_dup_fist_frag; }
static inline uint64_t get_ip6_flow_bypass_dup_last_frag(struct thread_stat *thr_stat) { return thr_stat->ip_reassembly->ip6_flow_bypass_dup_last_frag; }
static inline uint64_t get_total_nr_tcp_sess_used(struct thread_stat *thr_stat) { return thr_stat->session_mgr->total_nr_tcp_sess_used; }
static inline uint64_t get_curr_nr_tcp_sess_used(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_nr_tcp_sess_used; }
static inline uint64_t get_curr_nr_tcp_sess_opening(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_nr_tcp_sess_opening; }
static inline uint64_t get_curr_nr_tcp_sess_active(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_nr_tcp_sess_active; }
static inline uint64_t get_curr_nr_tcp_sess_closing(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_nr_tcp_sess_closing; }
static inline uint64_t get_curr_nr_tcp_sess_discard(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_nr_tcp_sess_discard; }
static inline uint64_t get_curr_nr_tcp_sess_closed(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_nr_tcp_sess_closed; }
static inline uint64_t get_total_nr_udp_sess_used(struct thread_stat *thr_stat) { return thr_stat->session_mgr->total_nr_udp_sess_used; }
static inline uint64_t get_curr_nr_udp_sess_used(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_nr_udp_sess_used; }
static inline uint64_t get_curr_nr_udp_sess_opening(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_nr_udp_sess_opening; }
static inline uint64_t get_curr_nr_udp_sess_active(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_nr_udp_sess_active; }
static inline uint64_t get_curr_nr_udp_sess_closing(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_nr_udp_sess_closing; }
static inline uint64_t get_curr_nr_udp_sess_discard(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_nr_udp_sess_discard; }
static inline uint64_t get_curr_nr_udp_sess_closed(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_nr_udp_sess_closed; }
static inline uint64_t get_nr_tcp_sess_evicted(struct thread_stat *thr_stat) { return thr_stat->session_mgr->nr_tcp_sess_evicted; }
static inline uint64_t get_nr_udp_sess_evicted(struct thread_stat *thr_stat) { return thr_stat->session_mgr->nr_udp_sess_evicted; }
static inline uint64_t get_nr_udp_pkts_nospace_bypass(struct thread_stat *thr_stat) { return thr_stat->session_mgr->nr_udp_pkts_nospace_bypass; }
static inline uint64_t get_nr_tcp_pkts_nospace_bypass(struct thread_stat *thr_stat) { return thr_stat->session_mgr->nr_tcp_pkts_nospace_bypass; }
static inline uint64_t get_nr_tcp_pkts_nosess_bypass(struct thread_stat *thr_stat) { return thr_stat->session_mgr->nr_tcp_pkts_nosess_bypass; }
static inline uint64_t get_nr_tcp_pkts_duped_bypass(struct thread_stat *thr_stat) { return thr_stat->session_mgr->nr_tcp_pkts_duped_bypass; }
static inline uint64_t get_nr_udp_pkts_duped_bypass(struct thread_stat *thr_stat) { return thr_stat->session_mgr->nr_udp_pkts_duped_bypass; }
static inline uint64_t get_nr_udp_pkts_evctd_bypass(struct thread_stat *thr_stat) { return thr_stat->session_mgr->nr_udp_pkts_evctd_bypass; }
static inline uint64_t get_nr_tcp_seg_received(struct thread_stat *thr_stat) { return thr_stat->session_mgr->nr_tcp_seg_received; }
static inline uint64_t get_nr_tcp_seg_expired(struct thread_stat *thr_stat) { return thr_stat->session_mgr->nr_tcp_seg_expired; }
static inline uint64_t get_nr_tcp_seg_retransmit(struct thread_stat *thr_stat) { return thr_stat->session_mgr->nr_tcp_seg_retransmit; }
static inline uint64_t get_nr_tcp_seg_overlap(struct thread_stat *thr_stat) { return thr_stat->session_mgr->nr_tcp_seg_overlap; }
static inline uint64_t get_nr_tcp_seg_no_space(struct thread_stat *thr_stat) { return thr_stat->session_mgr->nr_tcp_seg_no_space; }
static inline uint64_t get_nr_tcp_seg_inorder(struct thread_stat *thr_stat) { return thr_stat->session_mgr->nr_tcp_seg_inorder; }
static inline uint64_t get_nr_tcp_seg_reorded(struct thread_stat *thr_stat) { return thr_stat->session_mgr->nr_tcp_seg_reorded; }
static inline uint64_t get_nr_tcp_seg_buffered(struct thread_stat *thr_stat) { return thr_stat->session_mgr->nr_tcp_seg_buffered; }
static inline uint64_t get_nr_tcp_seg_released(struct thread_stat *thr_stat) { return thr_stat->session_mgr->nr_tcp_seg_released; }
static inline uint64_t get_total_tcp_sess_used(struct thread_stat *thr_stat) { return thr_stat->session_mgr->total_tcp_sess_used; }
static inline uint64_t get_curr_tcp_sess_used(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_tcp_sess_used; }
static inline uint64_t get_curr_tcp_sess_opening(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_tcp_sess_opening; }
static inline uint64_t get_curr_tcp_sess_active(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_tcp_sess_active; }
static inline uint64_t get_curr_tcp_sess_closing(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_tcp_sess_closing; }
static inline uint64_t get_curr_tcp_sess_discard(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_tcp_sess_discard; }
static inline uint64_t get_curr_tcp_sess_closed(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_tcp_sess_closed; }
static inline uint64_t get_total_udp_sess_used(struct thread_stat *thr_stat) { return thr_stat->session_mgr->total_udp_sess_used; }
static inline uint64_t get_curr_udp_sess_used(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_udp_sess_used; }
static inline uint64_t get_curr_udp_sess_opening(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_udp_sess_opening; }
static inline uint64_t get_curr_udp_sess_active(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_udp_sess_active; }
static inline uint64_t get_curr_udp_sess_closing(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_udp_sess_closing; }
static inline uint64_t get_curr_udp_sess_discard(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_udp_sess_discard; }
static inline uint64_t get_curr_udp_sess_closed(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_udp_sess_closed; }
static inline uint64_t get_tcp_sess_evicted(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_sess_evicted; }
static inline uint64_t get_udp_sess_evicted(struct thread_stat *thr_stat) { return thr_stat->session_mgr->udp_sess_evicted; }
static inline uint64_t get_udp_pkts_nospace_bypass(struct thread_stat *thr_stat) { return thr_stat->session_mgr->udp_pkts_nospace_bypass; }
static inline uint64_t get_tcp_pkts_nospace_bypass(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_pkts_nospace_bypass; }
static inline uint64_t get_tcp_pkts_nosess_bypass(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_pkts_nosess_bypass; }
static inline uint64_t get_tcp_pkts_duped_bypass(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_pkts_duped_bypass; }
static inline uint64_t get_udp_pkts_duped_bypass(struct thread_stat *thr_stat) { return thr_stat->session_mgr->udp_pkts_duped_bypass; }
static inline uint64_t get_udp_pkts_evctd_bypass(struct thread_stat *thr_stat) { return thr_stat->session_mgr->udp_pkts_evctd_bypass; }
static inline uint64_t get_tcp_seg_received(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_seg_received; }
static inline uint64_t get_tcp_seg_expired(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_seg_expired; }
static inline uint64_t get_tcp_seg_retransmit(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_seg_retransmit; }
static inline uint64_t get_tcp_seg_overlap(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_seg_overlap; }
static inline uint64_t get_tcp_seg_no_space(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_seg_no_space; }
static inline uint64_t get_tcp_seg_inorder(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_seg_inorder; }
static inline uint64_t get_tcp_seg_reorded(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_seg_reorded; }
static inline uint64_t get_tcp_seg_buffered(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_seg_buffered; }
static inline uint64_t get_tcp_seg_released(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_seg_released; }
struct metric_schema
{
@@ -138,41 +138,41 @@ struct metric_schema
{"ip6_flow_bypass_dup_fist_frag", get_ip6_flow_bypass_dup_fist_frag},
{"ip6_flow_bypass_dup_last_frag", get_ip6_flow_bypass_dup_last_frag},
// TCP session
{"total_nr_tcp_sess_used", get_total_nr_tcp_sess_used},
{"curr_nr_tcp_sess_used", get_curr_nr_tcp_sess_used},
{"curr_nr_tcp_sess_opening", get_curr_nr_tcp_sess_opening},
{"curr_nr_tcp_sess_active", get_curr_nr_tcp_sess_active},
{"curr_nr_tcp_sess_closing", get_curr_nr_tcp_sess_closing},
{"curr_nr_tcp_sess_discard", get_curr_nr_tcp_sess_discard},
{"curr_nr_tcp_sess_closed", get_curr_nr_tcp_sess_closed},
{"total_tcp_sess_used", get_total_tcp_sess_used},
{"curr_tcp_sess_used", get_curr_tcp_sess_used},
{"curr_tcp_sess_opening", get_curr_tcp_sess_opening},
{"curr_tcp_sess_active", get_curr_tcp_sess_active},
{"curr_tcp_sess_closing", get_curr_tcp_sess_closing},
{"curr_tcp_sess_discard", get_curr_tcp_sess_discard},
{"curr_tcp_sess_closed", get_curr_tcp_sess_closed},
// UDP session
{"total_nr_udp_sess_used", get_total_nr_udp_sess_used},
{"curr_nr_udp_sess_used", get_curr_nr_udp_sess_used},
{"curr_nr_udp_sess_opening", get_curr_nr_udp_sess_opening},
{"curr_nr_udp_sess_active", get_curr_nr_udp_sess_active},
{"curr_nr_udp_sess_closing", get_curr_nr_udp_sess_closing},
{"curr_nr_udp_sess_discard", get_curr_nr_udp_sess_discard},
{"curr_nr_udp_sess_closed", get_curr_nr_udp_sess_closed},
{"total_udp_sess_used", get_total_udp_sess_used},
{"curr_udp_sess_used", get_curr_udp_sess_used},
{"curr_udp_sess_opening", get_curr_udp_sess_opening},
{"curr_udp_sess_active", get_curr_udp_sess_active},
{"curr_udp_sess_closing", get_curr_udp_sess_closing},
{"curr_udp_sess_discard", get_curr_udp_sess_discard},
{"curr_udp_sess_closed", get_curr_udp_sess_closed},
// Evicted session
{"nr_tcp_sess_evicted", get_nr_tcp_sess_evicted},
{"nr_udp_sess_evicted", get_nr_udp_sess_evicted},
{"tcp_sess_evicted", get_tcp_sess_evicted},
{"udp_sess_evicted", get_udp_sess_evicted},
// Packet
{"nr_udp_pkts_nospace_bypass", get_nr_udp_pkts_nospace_bypass},
{"nr_tcp_pkts_nospace_bypass", get_nr_tcp_pkts_nospace_bypass},
{"nr_tcp_pkts_nosess_bypass", get_nr_tcp_pkts_nosess_bypass},
{"nr_tcp_pkts_duped_bypass", get_nr_tcp_pkts_duped_bypass},
{"nr_udp_pkts_duped_bypass", get_nr_udp_pkts_duped_bypass},
{"nr_udp_pkts_evctd_bypass", get_nr_udp_pkts_evctd_bypass},
{"udp_pkts_nospace_bypass", get_udp_pkts_nospace_bypass},
{"tcp_pkts_nospace_bypass", get_tcp_pkts_nospace_bypass},
{"tcp_pkts_nosess_bypass", get_tcp_pkts_nosess_bypass},
{"tcp_pkts_duped_bypass", get_tcp_pkts_duped_bypass},
{"udp_pkts_duped_bypass", get_udp_pkts_duped_bypass},
{"udp_pkts_evctd_bypass", get_udp_pkts_evctd_bypass},
// TCP segments
{"nr_tcp_seg_received", get_nr_tcp_seg_received},
{"nr_tcp_seg_expired", get_nr_tcp_seg_expired},
{"nr_tcp_seg_retransmit", get_nr_tcp_seg_retransmit},
{"nr_tcp_seg_overlap", get_nr_tcp_seg_overlap},
{"nr_tcp_seg_no_space", get_nr_tcp_seg_no_space},
{"nr_tcp_seg_inorder", get_nr_tcp_seg_inorder},
{"nr_tcp_seg_reorded", get_nr_tcp_seg_reorded},
{"nr_tcp_seg_buffered", get_nr_tcp_seg_buffered},
{"nr_tcp_seg_released", get_nr_tcp_seg_released},
{"tcp_seg_received", get_tcp_seg_received},
{"tcp_seg_expired", get_tcp_seg_expired},
{"tcp_seg_retransmit", get_tcp_seg_retransmit},
{"tcp_seg_overlap", get_tcp_seg_overlap},
{"tcp_seg_no_space", get_tcp_seg_no_space},
{"tcp_seg_inorder", get_tcp_seg_inorder},
{"tcp_seg_reorded", get_tcp_seg_reorded},
{"tcp_seg_buffered", get_tcp_seg_buffered},
{"tcp_seg_released", get_tcp_seg_released},
};
struct stellar_stat