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

Modify the stat of session manager

Browse Source
This commit is contained in:
luwenpeng
2024-04-09 10:36:39 +08:00
parent daff1ecbc7
commit 3b00acab81
14 changed files with 536 additions and 528 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
src/session/session.cpp
View File

@@ -200,7 +200,8 @@ struct tcp_segment *session_get_tcp_segment(struct session *sess)
struct tcp_segment *seg = tcp_reassembly_pop(half->assembler);
if (seg)
{
half->nr_seg_reorded++;
sess->mgr_stat->nr_tcp_seg_reorded++;
half->nr_tcp_seg_reorded++;
}
return seg;
}
@@ -231,7 +232,8 @@ void session_free_tcp_segment(struct session *sess, struct tcp_segment *seg)
}
else
{
half->nr_seg_released++;
sess->mgr_stat->nr_tcp_seg_released++;
half->nr_tcp_seg_released++;
tcp_segment_free(seg);
}
}
@@ -431,15 +433,15 @@ void tcp_half_dump(const struct tcp_half *half)
{
used += snprintf(buffer + used, sizeof(buffer) - used, "RST ");
}
printf(" flags : %s\n", buffer);
printf(" nr_seg_received : %lu\n", half->nr_seg_received);
printf(" nr_seg_expired : %lu\n", half->nr_seg_expired);
printf(" nr_seg_overlap : %lu\n", half->nr_seg_overlap);
printf(" nr_seg_no_space : %lu\n", half->nr_seg_no_space);
printf(" nr_seg_inorder : %lu\n", half->nr_seg_inorder);
printf(" nr_seg_reorded : %lu\n", half->nr_seg_reorded);
printf(" nr_seg_buffered : %lu\n", half->nr_seg_buffered);
printf(" nr_seg_released : %lu\n", half->nr_seg_released);
printf(" flags : %s\n", buffer);
printf(" nr_tcp_seg_received : %lu\n", half->nr_tcp_seg_received);
printf(" nr_tcp_seg_expired : %lu\n", half->nr_tcp_seg_expired);
printf(" nr_tcp_seg_overlap : %lu\n", half->nr_tcp_seg_overlap);
printf(" nr_tcp_seg_no_space : %lu\n", half->nr_tcp_seg_no_space);
printf(" nr_tcp_seg_inorder : %lu\n", half->nr_tcp_seg_inorder);
printf(" nr_tcp_seg_reorded : %lu\n", half->nr_tcp_seg_reorded);
printf(" nr_tcp_seg_buffered : %lu\n", half->nr_tcp_seg_buffered);
printf(" nr_tcp_seg_released : %lu\n", half->nr_tcp_seg_released);
}
void session_dump(struct session *sess)

18
src/session/session.h
View File

@@ -14,6 +14,7 @@ extern "C"
#include "timeout.h"
#include "uthash.h"
#include "tcp_reassembly.h"
#include "session_manager.h"
#define EX_DATA_MAX_COUNT 16
@@ -80,16 +81,16 @@ struct tcp_half
struct tcp_reassembly *assembler;
struct tcp_segment order;
uint64_t nr_seg_received;
uint64_t nr_seg_expired;
uint64_t nr_seg_overlap; //(retransmission)
uint64_t nr_seg_no_space;
uint64_t nr_tcp_seg_received;
uint64_t nr_tcp_seg_expired;
uint64_t nr_tcp_seg_overlap; //(retransmission)
uint64_t nr_tcp_seg_no_space;
uint64_t nr_seg_inorder;
uint64_t nr_seg_reorded;
uint64_t nr_tcp_seg_inorder;
uint64_t nr_tcp_seg_reorded;
uint64_t nr_seg_buffered;
uint64_t nr_seg_released;
uint64_t nr_tcp_seg_buffered;
uint64_t nr_tcp_seg_released;
uint32_t seq;
uint32_t ack;
@@ -130,6 +131,7 @@ struct session
void *user_data;
struct tcp_pcb tcp_pcb;
struct session_manager_stat *mgr_stat;
};
/******************************************************************************

301
src/session/session_manager.cpp
View File

@@ -30,6 +30,80 @@ struct session_manager
#define EVICTE_SESSION_BURST (RX_BURST_MAX)
/******************************************************************************
* Stat
******************************************************************************/
#define NR_SESS_STAT_INC(stat, state, type) \
{ \
switch ((state)) \
{ \
case SESSION_STATE_OPENING: \
(stat)->nr_##type##_sess_opening++; \
break; \
case SESSION_STATE_ACTIVE: \
(stat)->nr_##type##_sess_active++; \
break; \
case SESSION_STATE_CLOSING: \
(stat)->nr_##type##_sess_closing++; \
break; \
case SESSION_STATE_DISCARD: \
(stat)->nr_##type##_sess_discard++; \
break; \
case SESSION_STATE_CLOSED: \
(stat)->nr_##type##_sess_closed++; \
break; \
default: \
break; \
} \
}
#define NR_SESS_STAT_DEC(stat, state, type) \
{ \
switch ((state)) \
{ \
case SESSION_STATE_OPENING: \
(stat)->nr_##type##_sess_opening--; \
break; \
case SESSION_STATE_ACTIVE: \
(stat)->nr_##type##_sess_active--; \
break; \
case SESSION_STATE_CLOSING: \
(stat)->nr_##type##_sess_closing--; \
break; \
case SESSION_STATE_DISCARD: \
(stat)->nr_##type##_sess_discard--; \
break; \
case SESSION_STATE_CLOSED: \
(stat)->nr_##type##_sess_closed--; \
break; \
default: \
break; \
} \
}
#define NR_SESS_STAT_UPDATE(stat, curr, next, type) \
{ \
if (curr != next) \
{ \
NR_SESS_STAT_DEC(stat, curr, type); \
NR_SESS_STAT_INC(stat, next, type); \
} \
}
#define NR_TCP_SESS_STAT_INC(stat, state) NR_SESS_STAT_INC(stat, state, tcp)
#define NR_UDP_SESS_STAT_INC(stat, state) NR_SESS_STAT_INC(stat, state, udp)
#define NR_TCP_SESS_STAT_DEC(stat, state) NR_SESS_STAT_DEC(stat, state, tcp)
#define NR_UDP_SESS_STAT_DEC(stat, state) NR_SESS_STAT_DEC(stat, state, udp)
#define NR_TCP_SESS_STAT_UPDATE(stat, curr, next) NR_SESS_STAT_UPDATE(stat, curr, next, tcp)
#define NR_UDP_SESS_STAT_UPDATE(stat, curr, next) NR_SESS_STAT_UPDATE(stat, curr, next, udp)
/******************************************************************************
* Options
******************************************************************************/
static int check_options(const struct session_manager_options *opts)
{
if (opts == NULL)
@@ -155,6 +229,10 @@ static int check_options(const struct session_manager_options *opts)
return 0;
}
/******************************************************************************
* TCP protocol control block
******************************************************************************/
/*
* The next routines deal with comparing 32 bit unsigned ints
* and worry about wraparound (automatic with unsigned arithmetic).
@@ -193,7 +271,7 @@ static int tcp_pcb_init(struct tcp_pcb *pcb, uint8_t tcp_reassembly_enable, uint
return 0;
}
static void tcp_pcb_update(struct tcp_pcb *pcb, enum session_dir dir, const struct pkt_layer *tcp_layer, uint64_t now)
static void tcp_pcb_update(struct session_manager_stat *stat, struct tcp_pcb *pcb, enum session_dir dir, const struct pkt_layer *tcp_layer, uint64_t now)
{
struct tcp_segment *seg;
struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr;
@@ -208,8 +286,10 @@ static void tcp_pcb_update(struct tcp_pcb *pcb, enum session_dir dir, const stru
{
if (tcp_layer->pld_len)
{
half->nr_seg_received++;
half->nr_seg_inorder++;
half->nr_tcp_seg_received++;
half->nr_tcp_seg_inorder++;
stat->nr_tcp_seg_received++;
stat->nr_tcp_seg_inorder++;
half->order.data = tcp_layer->pld_ptr;
half->order.len = tcp_layer->pld_len;
}
@@ -224,42 +304,51 @@ static void tcp_pcb_update(struct tcp_pcb *pcb, enum session_dir dir, const stru
seg = tcp_reassembly_expire(half->assembler, now);
if (seg)
{
half->nr_seg_expired++;
half->nr_seg_released++;
half->nr_tcp_seg_expired++;
half->nr_tcp_seg_released++;
stat->nr_tcp_seg_expired++;
stat->nr_tcp_seg_released++;
tcp_segment_free(seg);
}
if (tcp_layer->pld_len)
{
half->nr_seg_received++;
half->nr_tcp_seg_received++;
stat->nr_tcp_seg_received++;
uint32_t rcv_nxt = tcp_reassembly_get_recv_next(half->assembler);
if (half->seq == rcv_nxt)
{
half->nr_seg_inorder++;
half->nr_tcp_seg_inorder++;
stat->nr_tcp_seg_inorder++;
half->order.data = tcp_layer->pld_ptr;
half->order.len = tcp_layer->pld_len;
tcp_reassembly_inc_recv_next(half->assembler, tcp_layer->pld_len);
}
else if (before(half->seq, rcv_nxt))
{
// TODO add metric (overlap)
half->nr_seg_overlap++;
half->nr_tcp_seg_overlap++;
stat->nr_tcp_seg_overlap++;
}
else if ((seg = tcp_segment_new(half->seq, tcp_layer->pld_ptr, tcp_layer->pld_len)))
{
switch (tcp_reassembly_push(half->assembler, seg, now))
{
case -1:
half->nr_seg_no_space++;
half->nr_tcp_seg_no_space++;
stat->nr_tcp_seg_no_space++;
tcp_segment_free(seg);
break;
case 0:
half->nr_seg_buffered++;
half->nr_tcp_seg_buffered++;
stat->nr_tcp_seg_buffered++;
break;
case 1:
half->nr_seg_buffered++;
half->nr_seg_overlap++;
half->nr_tcp_seg_buffered++;
half->nr_tcp_seg_overlap++;
stat->nr_tcp_seg_buffered++;
stat->nr_tcp_seg_overlap++;
break;
default:
assert(0);
@@ -268,86 +357,12 @@ static void tcp_pcb_update(struct tcp_pcb *pcb, enum session_dir dir, const stru
}
else
{
half->nr_seg_no_space++;
half->nr_tcp_seg_no_space++;
stat->nr_tcp_seg_no_space++;
}
}
}
/******************************************************************************
* Stat
******************************************************************************/
static void session_stat_inc(struct session_stat *stat, enum session_state state)
{
switch (state)
{
case SESSION_STATE_INIT:
stat->nr_sess_init++;
break;
case SESSION_STATE_OPENING:
stat->nr_sess_opening++;
break;
case SESSION_STATE_ACTIVE:
stat->nr_sess_active++;
break;
case SESSION_STATE_CLOSING:
stat->nr_sess_closing++;
break;
case SESSION_STATE_DISCARD:
stat->nr_sess_discard++;
break;
case SESSION_STATE_CLOSED:
stat->nr_sess_closed++;
break;
default:
break;
}
}
static void session_stat_dec(struct session_stat *stat, enum session_state state)
{
switch (state)
{
case SESSION_STATE_INIT:
stat->nr_sess_init--;
break;
case SESSION_STATE_OPENING:
stat->nr_sess_opening--;
break;
case SESSION_STATE_ACTIVE:
stat->nr_sess_active--;
break;
case SESSION_STATE_CLOSING:
stat->nr_sess_closing--;
break;
case SESSION_STATE_DISCARD:
stat->nr_sess_discard--;
break;
case SESSION_STATE_CLOSED:
stat->nr_sess_closed--;
break;
default:
break;
}
}
static void session_stat_update(struct session_manager *mgr, struct session *sess, enum session_state curr_state, enum session_state next_state)
{
switch (session_get_type(sess))
{
case SESSION_TYPE_TCP:
session_stat_dec(&mgr->stat.tcp_sess, curr_state);
session_stat_inc(&mgr->stat.tcp_sess, next_state);
break;
case SESSION_TYPE_UDP:
session_stat_dec(&mgr->stat.udp_sess, curr_state);
session_stat_inc(&mgr->stat.udp_sess, next_state);
break;
default:
break;
}
}
/******************************************************************************
* Session Direction
******************************************************************************/
@@ -405,20 +420,16 @@ static int session_manager_self_protection(struct session_manager *mgr, struct s
switch (key->ip_proto)
{
case IPPROTO_TCP:
if (stat->tcp_sess.nr_sess_used >= mgr->opts.max_tcp_session_num)
if (stat->nr_tcp_sess_used >= mgr->opts.max_tcp_session_num)
{
stat->evc_pkt.nr_pkts++;
stat->evc_pkt.nr_bytes += packet_get_len(pkt);
stat->tcp_sess.nr_new_sess_evicted++;
stat->nr_tcp_pkts_bypass_no_space++;
return 1;
}
break;
case IPPROTO_UDP:
if (stat->udp_sess.nr_sess_used >= mgr->opts.max_udp_session_num)
if (stat->nr_udp_sess_used >= mgr->opts.max_udp_session_num)
{
stat->evc_pkt.nr_pkts++;
stat->evc_pkt.nr_bytes += packet_get_len(pkt);
stat->udp_sess.nr_new_sess_evicted++;
stat->nr_udp_pkts_bypass_no_space++;
return 1;
}
break;
@@ -434,8 +445,7 @@ static int session_manager_filter_evicted_session(struct session_manager *mgr, s
{
if (mgr->opts.evicted_session_filter_enable && evicted_session_filter_lookup(mgr->evicte_sess_filter, key, now))
{
mgr->stat.evc_pkt.nr_pkts++;
mgr->stat.evc_pkt.nr_bytes += packet_get_len(pkt);
mgr->stat.nr_udp_pkts_bypass_hit_evc++;
return 1;
}
@@ -457,8 +467,7 @@ static int session_manager_filter_duplicated_packet(struct session_manager *mgr,
{
if (duplicated_packet_filter_lookup(mgr->dup_pkt_filter, pkt, now))
{
mgr->stat.dup_pkt.nr_pkts++;
mgr->stat.dup_pkt.nr_bytes += packet_get_len(pkt);
mgr->stat.nr_tcp_pkts_bypass_hit_dup++;
session_set_dup_traffic(sess);
return 1;
}
@@ -570,7 +579,6 @@ static void session_manager_evicte_session(struct session_manager *mgr, struct s
enum session_state next_state = session_transition_run(curr_state, LRU_EVICT);
session_transition_log(sess, curr_state, next_state, LRU_EVICT);
session_set_state(sess, next_state);
session_stat_update(mgr, sess, curr_state, next_state);
session_timer_del(mgr->sess_timer, sess);
session_set_closing_reason(sess, CLOSING_BY_EVICTED);
@@ -580,17 +588,19 @@ static void session_manager_evicte_session(struct session_manager *mgr, struct s
{
case SESSION_TYPE_TCP:
SESSION_LOG_DEBUG("evicte tcp old session: %lu", session_get_id(sess));
mgr->stat.tcp_sess.nr_old_sess_evicted++;
session_table_del(mgr->tcp_sess_table, session_get_tuple(sess));
NR_TCP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state);
mgr->stat.nr_tcp_sess_evicted++;
break;
case SESSION_TYPE_UDP:
SESSION_LOG_DEBUG("evicte udp old session: %lu", session_get_id(sess));
mgr->stat.udp_sess.nr_old_sess_evicted++;
session_table_del(mgr->udp_sess_table, session_get_tuple(sess));
if (mgr->opts.evicted_session_filter_enable)
{
evicted_session_filter_add(mgr->evicte_sess_filter, session_get_tuple(sess), now);
}
NR_UDP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state);
mgr->stat.nr_udp_sess_evicted++;
break;
default:
assert(0);
@@ -605,11 +615,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_bypass_miss_sess++;
return NULL;
}
// tcp table full evict old session
if (mgr->opts.tcp_overload_evict_old_sess && mgr->stat.tcp_sess.nr_sess_used >= mgr->opts.max_tcp_session_num - EVICTE_SESSION_BURST)
if (mgr->opts.tcp_overload_evict_old_sess && mgr->stat.nr_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, now);
@@ -623,6 +634,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
return NULL;
}
session_init(sess);
sess->mgr_stat = &mgr->stat;
session_set_id(sess, id_generator_alloc());
if (tcp_pcb_init(&sess->tcp_pcb, mgr->opts.tcp_reassembly_enable, mgr->opts.tcp_reassembly_max_timeout, mgr->opts.tcp_reassembly_max_segments) == -1)
@@ -631,12 +643,11 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
session_pool_push(mgr->sess_pool, sess);
return NULL;
}
tcp_pcb_update(&sess->tcp_pcb, dir, tcp_layer, now);
tcp_pcb_update(&mgr->stat, &sess->tcp_pcb, dir, tcp_layer, now);
enum session_state next_state = session_transition_run(SESSION_STATE_INIT, TCP_SYN);
session_update(sess, next_state, pkt, key, dir, now);
session_transition_log(sess, SESSION_STATE_INIT, next_state, TCP_SYN);
session_stat_inc(&mgr->stat.tcp_sess, next_state);
uint64_t timeout = (flags & TH_ACK) ? mgr->opts.tcp_handshake_timeout : mgr->opts.tcp_init_timeout;
session_timer_update(mgr->sess_timer, sess, now + timeout);
@@ -648,7 +659,8 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
duplicated_packet_filter_add(mgr->dup_pkt_filter, pkt, now);
}
mgr->stat.tcp_sess.nr_sess_used++;
NR_TCP_SESS_STAT_INC(&mgr->stat, next_state);
mgr->stat.nr_tcp_sess_used++;
return sess;
}
@@ -656,7 +668,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, uint64_t now)
{
// udp table full evict old session
if (mgr->opts.udp_overload_evict_old_sess && mgr->stat.udp_sess.nr_sess_used >= mgr->opts.max_udp_session_num - EVICTE_SESSION_BURST)
if (mgr->opts.udp_overload_evict_old_sess && mgr->stat.nr_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, now);
@@ -668,19 +680,21 @@ static struct session *session_manager_new_udp_session(struct session_manager *m
assert(sess);
return NULL;
}
mgr->stat.udp_sess.nr_sess_used++;
session_init(sess);
sess->mgr_stat = &mgr->stat;
session_set_id(sess, id_generator_alloc());
enum session_dir dir = identify_direction_by_port(ntohs(key->src_port), ntohs(key->dst_port));
enum session_state next_state = session_transition_run(SESSION_STATE_INIT, UDP_DATA);
session_update(sess, next_state, pkt, key, dir, now);
session_transition_log(sess, SESSION_STATE_INIT, next_state, UDP_DATA);
session_stat_inc(&mgr->stat.udp_sess, next_state);
session_timer_update(mgr->sess_timer, sess, now + mgr->opts.udp_data_timeout);
session_table_add(mgr->udp_sess_table, key, sess);
NR_UDP_SESS_STAT_INC(&mgr->stat, next_state);
mgr->stat.nr_udp_sess_used++;
return sess;
}
@@ -702,11 +716,10 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
// update session
session_update(sess, next_state, pkt, key, dir, now);
session_stat_update(mgr, sess, curr_state, next_state);
session_transition_log(sess, curr_state, next_state, inputs);
// update tcp pcb
tcp_pcb_update(&sess->tcp_pcb, dir, tcp_layer, now);
tcp_pcb_update(&mgr->stat, &sess->tcp_pcb, dir, tcp_layer, now);
if (mgr->opts.duplicated_packet_filter_enable)
{
@@ -770,6 +783,8 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
}
session_timer_update(mgr->sess_timer, sess, now + timeout);
NR_TCP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state);
return 0;
}
@@ -780,9 +795,10 @@ static int session_manager_update_udp_session(struct session_manager *mgr, struc
enum session_state next_state = session_transition_run(curr_state, UDP_DATA);
session_update(sess, next_state, pkt, key, dir, now);
session_transition_log(sess, curr_state, next_state, UDP_DATA);
session_stat_update(mgr, sess, curr_state, next_state);
session_timer_update(mgr->sess_timer, sess, now + mgr->opts.udp_data_timeout);
NR_UDP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state);
return 0;
}
@@ -913,13 +929,13 @@ void session_manager_free_session(struct session_manager *mgr, struct session *s
case SESSION_TYPE_TCP:
tcp_pcb_clean(&sess->tcp_pcb);
session_table_del(mgr->tcp_sess_table, session_get_tuple(sess));
session_stat_dec(&mgr->stat.tcp_sess, session_get_state(sess));
mgr->stat.tcp_sess.nr_sess_used--;
NR_TCP_SESS_STAT_DEC(&mgr->stat, session_get_state(sess));
mgr->stat.nr_tcp_sess_used--;
break;
case SESSION_TYPE_UDP:
session_table_del(mgr->udp_sess_table, session_get_tuple(sess));
session_stat_dec(&mgr->stat.udp_sess, session_get_state(sess));
mgr->stat.udp_sess.nr_sess_used--;
NR_UDP_SESS_STAT_DEC(&mgr->stat, session_get_state(sess));
mgr->stat.nr_udp_sess_used--;
break;
default:
assert(0);
@@ -984,7 +1000,22 @@ struct session *session_manager_get_expired_session(struct session_manager *mgr,
enum session_state next_state = session_transition_run(curr_state, TIMEOUT);
session_transition_log(sess, curr_state, next_state, TIMEOUT);
session_set_state(sess, next_state);
session_stat_update(mgr, sess, curr_state, next_state);
uint64_t timeout = 0;
switch (session_get_type(sess))
{
case SESSION_TYPE_TCP:
timeout = mgr->opts.tcp_data_timeout;
NR_TCP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state);
break;
case SESSION_TYPE_UDP:
timeout = mgr->opts.udp_data_timeout;
NR_UDP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state);
break;
default:
assert(0);
break;
}
if (next_state == SESSION_STATE_CLOSED)
{
@@ -998,19 +1029,6 @@ struct session *session_manager_get_expired_session(struct session_manager *mgr,
else
{
// in closing state, only update timeout
uint64_t timeout = 0;
switch (session_get_type(sess))
{
case SESSION_TYPE_TCP:
timeout = mgr->opts.tcp_data_timeout;
break;
case SESSION_TYPE_UDP:
timeout = mgr->opts.udp_data_timeout;
break;
default:
assert(0);
break;
}
session_timer_update(mgr->sess_timer, sess, now + timeout);
return NULL;
}
@@ -1042,17 +1060,14 @@ void session_manager_print_stat(struct session_manager *mgr)
{
if (mgr)
{
SESSION_LOG_DEBUG("session_manager_stat->tcp_sess_num: used: %u, init: %u, opening: %u, active: %u, closing: %u, closed: %u, evic_new: %u, evic_old: %u",
mgr->stat.tcp_sess.nr_sess_used, mgr->stat.tcp_sess.nr_sess_init, mgr->stat.tcp_sess.nr_sess_opening,
mgr->stat.tcp_sess.nr_sess_active, mgr->stat.tcp_sess.nr_sess_closing, mgr->stat.tcp_sess.nr_sess_closed,
mgr->stat.tcp_sess.nr_new_sess_evicted, mgr->stat.tcp_sess.nr_old_sess_evicted);
SESSION_LOG_DEBUG("session_manager_stat->udp_sess_num: used: %u, init: %u, opening: %u, active: %u, closing: %u, closed: %u, evic_new: %u, evic_old: %u",
mgr->stat.udp_sess.nr_sess_used, mgr->stat.udp_sess.nr_sess_init, mgr->stat.udp_sess.nr_sess_opening,
mgr->stat.udp_sess.nr_sess_active, mgr->stat.udp_sess.nr_sess_closing, mgr->stat.udp_sess.nr_sess_closed,
mgr->stat.udp_sess.nr_new_sess_evicted, mgr->stat.udp_sess.nr_old_sess_evicted);
SESSION_LOG_DEBUG("session_manager_stat: dup_pkts: %u, dup_bytes: %u, evic_pkts: %u, evic_bytes: %u",
mgr->stat.dup_pkt.nr_pkts, mgr->stat.dup_pkt.nr_bytes,
mgr->stat.evc_pkt.nr_pkts, mgr->stat.evc_pkt.nr_bytes);
SESSION_LOG_DEBUG("session_manager_stat->tcp_sess: used: %u, opening: %u, active: %u, closing: %u, closed: %u",
mgr->stat.nr_tcp_sess_used, mgr->stat.nr_tcp_sess_opening, mgr->stat.nr_tcp_sess_active,
mgr->stat.nr_tcp_sess_closing, mgr->stat.nr_tcp_sess_closed);
SESSION_LOG_DEBUG("session_manager_stat->udp_sess: used: %u, opening: %u, active: %u, closing: %u, closed: %u",
mgr->stat.nr_udp_sess_used, mgr->stat.nr_udp_sess_opening, mgr->stat.nr_udp_sess_active,
mgr->stat.nr_udp_sess_closing, mgr->stat.nr_udp_sess_closed);
SESSION_LOG_DEBUG("session_manager_stat->evicted_sess: tcp: %u, udp: %u",
mgr->stat.nr_tcp_sess_evicted, mgr->stat.nr_udp_sess_evicted);
}
}

67
src/session/session_manager.h
View File

@@ -51,33 +51,52 @@ struct session_manager_options
uint32_t tcp_reassembly_max_segments; // range: [2, 32]
};
struct session_stat
{
uint64_t nr_sess_used;
uint64_t nr_sess_init;
uint64_t nr_sess_opening;
uint64_t nr_sess_active;
uint64_t nr_sess_closing;
uint64_t nr_sess_discard;
uint64_t nr_sess_closed;
uint64_t nr_new_sess_evicted;
uint64_t nr_old_sess_evicted;
};
struct packet_stat
{
uint64_t nr_pkts;
uint64_t nr_bytes;
};
struct session_manager_stat
{
struct packet_stat dup_pkt;
struct packet_stat evc_pkt;
/******************************************************
* state count
******************************************************/
struct session_stat tcp_sess;
struct session_stat udp_sess;
// TCP session
uint64_t nr_tcp_sess_used;
uint64_t nr_tcp_sess_opening;
uint64_t nr_tcp_sess_active;
uint64_t nr_tcp_sess_closing;
uint64_t nr_tcp_sess_discard;
uint64_t nr_tcp_sess_closed;
// UDP session
uint64_t nr_udp_sess_used;
uint64_t nr_udp_sess_opening;
uint64_t nr_udp_sess_active;
uint64_t nr_udp_sess_closing;
uint64_t nr_udp_sess_discard;
uint64_t nr_udp_sess_closed;
/******************************************************
* sum count
******************************************************/
// Evicted session
uint64_t nr_tcp_sess_evicted;
uint64_t nr_udp_sess_evicted;
// Packet
uint64_t nr_udp_pkts_bypass_no_space;
uint64_t nr_tcp_pkts_bypass_no_space;
uint64_t nr_tcp_pkts_bypass_miss_sess;
uint64_t nr_tcp_pkts_bypass_hit_dup;
uint64_t nr_udp_pkts_bypass_hit_evc;
// TCP segments
uint64_t nr_tcp_seg_received;
uint64_t nr_tcp_seg_expired;
uint64_t nr_tcp_seg_overlap;
uint64_t nr_tcp_seg_no_space;
uint64_t nr_tcp_seg_inorder;
uint64_t nr_tcp_seg_reorded;
uint64_t nr_tcp_seg_buffered;
uint64_t nr_tcp_seg_released;
};
struct session_manager;

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

@@ -77,8 +77,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
// C2S SYN dup Packet
printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
@@ -93,8 +92,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
EXPECT_TRUE(session_has_dup_traffic(sess) == 1);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 1);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == sizeof(tcp_pkt1_c2s_syn));
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 1);
// C2S SYN retransmission Packet
printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
@@ -112,8 +110,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
EXPECT_TRUE(session_has_dup_traffic(sess) == 1);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 1);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == sizeof(tcp_pkt1_c2s_syn));
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 1);
session_manager_free(mgr);
}
@@ -143,8 +140,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
// S2C SYNACK dup Packet
printf("\n=> Packet Parse: TCP S2C SYNACK dup packet\n");
@@ -159,8 +155,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
EXPECT_TRUE(session_has_dup_traffic(sess) == 1);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 1);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == sizeof(tcp_pkt2_s2c_syn_ack));
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 1);
// S2C SYNACK retransmission Packet
printf("\n=> Packet Parse: TCP S2C SYNACK retransmission packet\n");
@@ -178,8 +173,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
EXPECT_TRUE(session_has_dup_traffic(sess) == 1);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 1);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == sizeof(tcp_pkt2_s2c_syn_ack));
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 1);
session_manager_free(mgr);
}
@@ -210,8 +204,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
// C2S SYN retransmission Packet
printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
@@ -228,8 +221,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
// C2S SYN retransmission Packet
printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
@@ -246,8 +238,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
// C2S SYN dup Packet
printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
@@ -262,8 +253,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
session_manager_free(mgr);
}
@@ -296,8 +286,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
// C2S SYN dup Packet
printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
@@ -312,8 +301,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
session_manager_free(mgr);
}
@@ -346,8 +334,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
// S2C SYNACK dup Packet
printf("\n=> Packet Parse: TCP S2C SYNACK dup packet\n");
@@ -362,8 +349,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
session_manager_free(mgr);
}

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

@@ -47,7 +47,7 @@ struct session_manager_options opts = {
.tcp_reassembly_max_segments = 16,
};
static void packet_set_tcp_src_addr(struct packet *pkt, uint32_t addr)
static void packet_set_ip_src_addr(struct packet *pkt, uint32_t addr)
{
const struct pkt_layer *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_TYPE_IPV4);
EXPECT_TRUE(ipv4_layer);
@@ -73,23 +73,21 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
// new session
for (uint32_t i = 0; i < opts.max_tcp_session_num; i++)
{
packet_set_tcp_src_addr(&pkt, i);
packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
}
printf("=> Session Manager: after add %lu new sessions\n", opts.max_tcp_session_num);
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == opts.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess.nr_sess_init == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closed == RX_BURST_MAX); // have evicted, have't free
EXPECT_TRUE(stat->tcp_sess.nr_new_sess_evicted == 0);
EXPECT_TRUE(stat->tcp_sess.nr_old_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->evc_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->evc_pkt.nr_bytes == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == opts.max_tcp_session_num);
EXPECT_TRUE(stat->nr_tcp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->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_bypass_no_space == 0);
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_miss_sess == 0);
session_manager_free(mgr);
}
@@ -116,28 +114,26 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
// new session
for (uint32_t i = 0; i < opts.max_tcp_session_num; i++)
{
packet_set_tcp_src_addr(&pkt, i);
packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
}
printf("=> Session Manager: after add %lu new sessions\n", opts.max_tcp_session_num);
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == opts.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess.nr_sess_init == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == opts.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closed == 0);
EXPECT_TRUE(stat->tcp_sess.nr_new_sess_evicted == 0);
EXPECT_TRUE(stat->tcp_sess.nr_old_sess_evicted == 0);
EXPECT_TRUE(stat->evc_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->evc_pkt.nr_bytes == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == opts.max_tcp_session_num);
EXPECT_TRUE(stat->nr_tcp_sess_opening == opts.max_tcp_session_num);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closed == 0);
EXPECT_TRUE(stat->nr_tcp_sess_evicted == 0);
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_no_space == 0);
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_miss_sess == 0);
// table full, evict new session
for (uint32_t i = 0; i < RX_BURST_MAX; i++)
{
packet_set_tcp_src_addr(&pkt, opts.max_tcp_session_num + i);
packet_set_ip_src_addr(&pkt, opts.max_tcp_session_num + i);
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL);
}
@@ -145,16 +141,14 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == opts.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess.nr_sess_init == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == opts.max_tcp_session_num);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closed == 0);
EXPECT_TRUE(stat->tcp_sess.nr_new_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->tcp_sess.nr_old_sess_evicted == 0);
EXPECT_TRUE(stat->evc_pkt.nr_pkts == RX_BURST_MAX);
EXPECT_TRUE(stat->evc_pkt.nr_bytes == RX_BURST_MAX * sizeof(tcp_pkt1_c2s_syn));
EXPECT_TRUE(stat->nr_tcp_sess_used == opts.max_tcp_session_num);
EXPECT_TRUE(stat->nr_tcp_sess_opening == opts.max_tcp_session_num);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closed == 0);
EXPECT_TRUE(stat->nr_tcp_sess_evicted == 0);
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_no_space == RX_BURST_MAX);
EXPECT_TRUE(stat->nr_tcp_pkts_bypass_miss_sess == 0);
session_manager_free(mgr);
}

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

@@ -47,7 +47,7 @@ struct session_manager_options opts = {
.tcp_reassembly_max_segments = 16,
};
static void packet_set_tcp_src_addr(struct packet *pkt, uint32_t addr)
static void packet_set_ip_src_addr(struct packet *pkt, uint32_t addr)
{
const struct pkt_layer *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_TYPE_IPV4);
EXPECT_TRUE(ipv4_layer);
@@ -74,23 +74,21 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
// new session
for (uint32_t i = 0; i < opts.max_udp_session_num; i++)
{
packet_set_tcp_src_addr(&pkt, i);
packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
}
printf("=> Session Manager: after add %lu new sessions\n", opts.max_udp_session_num);
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == opts.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess.nr_sess_init == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closed == RX_BURST_MAX); // have evicted, have't free
EXPECT_TRUE(stat->udp_sess.nr_new_sess_evicted == 0);
EXPECT_TRUE(stat->udp_sess.nr_old_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->evc_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->evc_pkt.nr_bytes == 0);
EXPECT_TRUE(stat->nr_udp_sess_used == opts.max_udp_session_num);
EXPECT_TRUE(stat->nr_udp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->nr_udp_sess_active == 0);
EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
EXPECT_TRUE(stat->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_bypass_no_space == 0);
EXPECT_TRUE(stat->nr_udp_pkts_bypass_hit_evc == 0);
// evicted session
while (1)
@@ -108,7 +106,7 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
for (uint32_t i = 0; i < RX_BURST_MAX; i++)
{
packet_set_tcp_src_addr(&pkt, i);
packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL); // hit evicted session, can't renew session
}
@@ -116,35 +114,31 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_sess.nr_sess_init == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closed == 0);
EXPECT_TRUE(stat->udp_sess.nr_new_sess_evicted == 0);
EXPECT_TRUE(stat->udp_sess.nr_old_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->evc_pkt.nr_pkts == RX_BURST_MAX);
EXPECT_TRUE(stat->evc_pkt.nr_bytes == RX_BURST_MAX * sizeof(udp_pkt1_dns_req));
EXPECT_TRUE(stat->nr_udp_sess_used == RX_BURST_MAX);
EXPECT_TRUE(stat->nr_udp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->nr_udp_sess_active == 0);
EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
EXPECT_TRUE(stat->nr_udp_sess_closed == 0);
EXPECT_TRUE(stat->nr_udp_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->nr_udp_pkts_bypass_no_space == 0);
EXPECT_TRUE(stat->nr_udp_pkts_bypass_hit_evc == RX_BURST_MAX);
// evicted session timeout
packet_set_tcp_src_addr(&pkt, 0);
packet_set_ip_src_addr(&pkt, 0);
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1 + opts.evicted_session_filter_timeout));
printf("=> Session Manager: after evicted session timeout\n");
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == RX_BURST_MAX + 1);
EXPECT_TRUE(stat->udp_sess.nr_sess_init == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closed == 1); // have evicted, have't free
EXPECT_TRUE(stat->udp_sess.nr_new_sess_evicted == 0);
EXPECT_TRUE(stat->udp_sess.nr_old_sess_evicted == RX_BURST_MAX + 1);
EXPECT_TRUE(stat->evc_pkt.nr_pkts == RX_BURST_MAX);
EXPECT_TRUE(stat->evc_pkt.nr_bytes == RX_BURST_MAX * sizeof(udp_pkt1_dns_req));
EXPECT_TRUE(stat->nr_udp_sess_used == RX_BURST_MAX + 1);
EXPECT_TRUE(stat->nr_udp_sess_opening == RX_BURST_MAX);
EXPECT_TRUE(stat->nr_udp_sess_active == 0);
EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
EXPECT_TRUE(stat->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_bypass_no_space == 0);
EXPECT_TRUE(stat->nr_udp_pkts_bypass_hit_evc == RX_BURST_MAX);
session_manager_free(mgr);
}
@@ -171,23 +165,21 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
// new session
for (uint32_t i = 0; i < opts.max_udp_session_num; i++)
{
packet_set_tcp_src_addr(&pkt, i);
packet_set_ip_src_addr(&pkt, i);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
}
printf("=> Session Manager: after add %lu new sessions\n", opts.max_udp_session_num);
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == opts.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess.nr_sess_init == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == opts.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closed == 0);
EXPECT_TRUE(stat->udp_sess.nr_new_sess_evicted == 0);
EXPECT_TRUE(stat->udp_sess.nr_old_sess_evicted == 0);
EXPECT_TRUE(stat->evc_pkt.nr_pkts == 0);
EXPECT_TRUE(stat->evc_pkt.nr_bytes == 0);
EXPECT_TRUE(stat->nr_udp_sess_used == opts.max_udp_session_num);
EXPECT_TRUE(stat->nr_udp_sess_opening == opts.max_udp_session_num);
EXPECT_TRUE(stat->nr_udp_sess_active == 0);
EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
EXPECT_TRUE(stat->nr_udp_sess_closed == 0);
EXPECT_TRUE(stat->nr_udp_sess_evicted == 0);
EXPECT_TRUE(stat->nr_udp_pkts_bypass_no_space == 0);
EXPECT_TRUE(stat->nr_udp_pkts_bypass_hit_evc == 0);
// evicted session
EXPECT_TRUE(session_manager_get_evicted_session(mgr) == NULL);
@@ -195,7 +187,7 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
// table full, evict new session
for (uint32_t i = 0; i < RX_BURST_MAX; i++)
{
packet_set_tcp_src_addr(&pkt, opts.max_udp_session_num + i);
packet_set_ip_src_addr(&pkt, opts.max_udp_session_num + i);
EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL);
}
@@ -203,16 +195,14 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == opts.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess.nr_sess_init == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == opts.max_udp_session_num);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closed == 0);
EXPECT_TRUE(stat->udp_sess.nr_new_sess_evicted == RX_BURST_MAX);
EXPECT_TRUE(stat->udp_sess.nr_old_sess_evicted == 0);
EXPECT_TRUE(stat->evc_pkt.nr_pkts == RX_BURST_MAX);
EXPECT_TRUE(stat->evc_pkt.nr_bytes == RX_BURST_MAX * sizeof(udp_pkt1_dns_req));
EXPECT_TRUE(stat->nr_udp_sess_used == opts.max_udp_session_num);
EXPECT_TRUE(stat->nr_udp_sess_opening == opts.max_udp_session_num);
EXPECT_TRUE(stat->nr_udp_sess_active == 0);
EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
EXPECT_TRUE(stat->nr_udp_sess_closed == 0);
EXPECT_TRUE(stat->nr_udp_sess_evicted == 0);
EXPECT_TRUE(stat->nr_udp_pkts_bypass_no_space == RX_BURST_MAX);
EXPECT_TRUE(stat->nr_udp_pkts_bypass_hit_evc == 0);
session_manager_free(mgr);
}

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

@@ -138,10 +138,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_time_wait_timeout);
@@ -156,10 +156,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -226,10 +226,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_unverified_rst_timeout);
@@ -244,10 +244,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -314,10 +314,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_unverified_rst_timeout);
@@ -332,10 +332,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -362,10 +362,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 1);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -381,10 +381,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -444,10 +444,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_half_closed_timeout);
@@ -462,10 +462,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -525,10 +525,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_half_closed_timeout);
@@ -543,10 +543,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}

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

@@ -97,10 +97,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_init_timeout) == NULL); // opening -> closing
@@ -116,10 +116,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -176,10 +176,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_handshake_timeout) == NULL);
@@ -195,10 +195,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -266,10 +266,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_handshake_timeout) == NULL);
@@ -285,10 +285,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -367,10 +367,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + opts.tcp_data_timeout) == NULL);
@@ -386,10 +386,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -464,10 +464,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_init_timeout) == NULL);
@@ -483,10 +483,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -562,10 +562,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_handshake_timeout) == NULL);
@@ -581,10 +581,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -652,10 +652,10 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -671,10 +671,10 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -742,10 +742,10 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -761,10 +761,10 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_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

@@ -402,10 +402,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 11 + opts.tcp_time_wait_timeout);
@@ -420,10 +420,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}

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

@@ -107,10 +107,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 1);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -126,10 +126,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -197,10 +197,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 1);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -216,10 +216,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}

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

@@ -119,10 +119,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_time_wait_timeout);
@@ -137,10 +137,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -215,10 +215,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_unverified_rst_timeout);
@@ -233,10 +233,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -311,10 +311,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_unverified_rst_timeout);
@@ -329,10 +329,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -368,10 +368,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_init_timeout) == NULL);
@@ -387,10 +387,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -458,10 +458,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_handshake_timeout) == NULL);
@@ -477,10 +477,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -559,10 +559,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + opts.tcp_data_timeout) == NULL);
@@ -578,10 +578,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -649,10 +649,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_half_closed_timeout);
@@ -667,10 +667,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -738,10 +738,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
// expire session
sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_half_closed_timeout);
@@ -756,10 +756,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
EXPECT_TRUE(stat->nr_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

@@ -122,10 +122,10 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 1);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_udp_sess_used == 1);
EXPECT_TRUE(stat->nr_udp_sess_opening == 0);
EXPECT_TRUE(stat->nr_udp_sess_active == 1);
EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.udp_data_timeout) == NULL); // active -> closing
@@ -141,10 +141,10 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_udp_sess_used == 0);
EXPECT_TRUE(stat->nr_udp_sess_opening == 0);
EXPECT_TRUE(stat->nr_udp_sess_active == 0);
EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
session_manager_free(mgr);
}

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

@@ -97,10 +97,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_udp_sess_used == 1);
EXPECT_TRUE(stat->nr_udp_sess_opening == 1);
EXPECT_TRUE(stat->nr_udp_sess_active == 0);
EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.udp_data_timeout) == NULL); // opening -> closing
@@ -116,10 +116,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_udp_sess_used == 0);
EXPECT_TRUE(stat->nr_udp_sess_opening == 0);
EXPECT_TRUE(stat->nr_udp_sess_active == 0);
EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
session_manager_free(mgr);
}
@@ -177,10 +177,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == 1);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == 1);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_udp_sess_used == 1);
EXPECT_TRUE(stat->nr_udp_sess_opening == 1);
EXPECT_TRUE(stat->nr_udp_sess_active == 0);
EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.udp_data_timeout) == NULL); // opening -> closing
@@ -198,10 +198,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
session_manager_print_stat(mgr);
stat = session_manager_get_stat(mgr);
EXPECT_TRUE(stat);
EXPECT_TRUE(stat->udp_sess.nr_sess_used == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_opening == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
EXPECT_TRUE(stat->nr_udp_sess_used == 0);
EXPECT_TRUE(stat->nr_udp_sess_opening == 0);
EXPECT_TRUE(stat->nr_udp_sess_active == 0);
EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
session_manager_free(mgr);
}