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

Modify the stat of session

Browse Source
This commit is contained in:
luwenpeng
2024-04-09 15:07:53 +08:00
parent 3b00acab81
commit a5a133bf91
13 changed files with 671 additions and 732 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/packet_io/packet_io_marsio.cpp
View File

@@ -244,11 +244,17 @@ void packet_io_marsio_drop(struct packet_io_marsio *handle, uint16_t thread_id,
{ {
pkt = &pkts[i]; pkt = &pkts[i];
tx_buff = (marsio_buff_t *)packet_get_user_data(pkt); tx_buff = (marsio_buff_t *)packet_get_user_data(pkt);
assert(tx_buff != NULL);
ATOMIC_ADD(&handle->stat.drop_pkts, 1); ATOMIC_ADD(&handle->stat.drop_pkts, 1);
ATOMIC_ADD(&handle->stat.drop_bytes, packet_get_len(pkt)); ATOMIC_ADD(&handle->stat.drop_bytes, packet_get_len(pkt));
if (tx_buff)
{
marsio_buff_free(handle->mr_ins, &tx_buff, 1, 0, thread_id); marsio_buff_free(handle->mr_ins, &tx_buff, 1, 0, thread_id);
} }
else // ip reassembly
{
}
packet_free(pkt);
}
} }
// pkts from packet_new // pkts from packet_new

142
src/session/session.cpp
View File

@@ -60,12 +60,12 @@ enum session_dir session_get_tuple_dir(const struct session *sess)
return sess->tuple_dir; return sess->tuple_dir;
} }
void session_set_cur_dir(struct session *sess, enum session_dir dir) void session_set_current_dir(struct session *sess, enum session_dir dir)
{ {
sess->cur_dir = dir; sess->cur_dir = dir;
} }
enum session_dir session_get_cur_dir(const struct session *sess) enum session_dir session_get_current_dir(const struct session *sess)
{ {
return sess->cur_dir; return sess->cur_dir;
} }
@@ -110,63 +110,44 @@ enum closing_reason session_get_closing_reason(const struct session *sess)
return sess->reason; return sess->reason;
} }
void session_inc_metric(struct session *sess, enum session_metric_index idx, uint64_t val) void session_inc_stat(struct session *sess, enum session_dir dir, enum session_stat stat, uint64_t val)
{ {
sess->metrics[idx] += val; sess->stats[dir][stat] += val;
} }
void session_set_metric(struct session *sess, enum session_metric_index idx, uint64_t val) uint64_t session_get_stat(const struct session *sess, enum session_dir dir, enum session_stat stat)
{ {
sess->metrics[idx] = val; return sess->stats[dir][stat];
} }
uint64_t session_get_metric(const struct session *sess, enum session_metric_index idx) void session_set_timestamp(struct session *sess, enum session_timestamp idx, uint64_t timestamp)
{
return sess->metrics[idx];
}
void session_set_timestamp(struct session *sess, enum session_timestamp_index idx, uint64_t timestamp)
{ {
sess->timestamps[idx] = timestamp; sess->timestamps[idx] = timestamp;
} }
uint64_t session_get_timestamp(const struct session *sess, enum session_timestamp_index idx) uint64_t session_get_timestamp(const struct session *sess, enum session_timestamp idx)
{ {
return sess->timestamps[idx]; return sess->timestamps[idx];
} }
void session_set_packet(struct session *sess, enum session_packet_index idx, const struct packet *pkt) void session_set_1st_packet(struct session *sess, enum session_dir dir, const struct packet *pkt)
{ {
if (idx == SESSION_PACKET_CURRENT) sess->first_pkt[dir] = packet_dup(pkt);
{
sess->packets[idx] = pkt;
}
else
{
if (sess->packets[idx])
{
return;
}
sess->packets[idx] = packet_dup(pkt);
}
} }
void session_clean_packet(struct session *sess, enum session_packet_index idx) const struct packet *session_get_1st_packet(const struct session *sess, enum session_dir dir)
{ {
if (idx == SESSION_PACKET_CURRENT) return sess->first_pkt[dir];
{
sess->packets[idx] = NULL;
}
else
{
packet_free((struct packet *)sess->packets[idx]);
sess->packets[idx] = NULL;
}
} }
const struct packet *session_get_packet(const struct session *sess, enum session_packet_index idx) void session_set_current_packet(struct session *sess, const struct packet *pkt)
{ {
return sess->packets[idx]; sess->curr_pkt = pkt;
}
const struct packet *session_get_current_packet(const struct session *sess)
{
return sess->curr_pkt;
} }
void session_set_user_data(struct session *sess, void *user_data) void session_set_user_data(struct session *sess, void *user_data)
@@ -181,27 +162,22 @@ void *session_get_user_data(const struct session *sess)
struct tcp_segment *session_get_tcp_segment(struct session *sess) struct tcp_segment *session_get_tcp_segment(struct session *sess)
{ {
struct tcp_half *half = NULL; enum session_dir dir = session_get_current_dir(sess);
if (session_get_cur_dir(sess) == SESSION_DIR_C2S) struct tcp_half *half = &sess->tcp_halfs[dir];
{
half = &sess->tcp_pcb.c2s;
}
else
{
half = &sess->tcp_pcb.s2c;
}
if (half->order.data != NULL && half->order.len > 0) if (half->in_order.data != NULL && half->in_order.len > 0)
{ {
return &half->order; return &half->in_order;
} }
else else
{ {
struct tcp_segment *seg = tcp_reassembly_pop(half->assembler); struct tcp_segment *seg = tcp_reassembly_pop(half->assembler);
if (seg) if (seg)
{ {
session_inc_stat(sess, dir, STAT_TCP_SEGS_REORDERED, 1);
session_inc_stat(sess, dir, STAT_TCP_PLDS_REORDERED, seg->len);
sess->mgr_stat->nr_tcp_seg_reorded++; sess->mgr_stat->nr_tcp_seg_reorded++;
half->nr_tcp_seg_reorded++;
} }
return seg; return seg;
} }
@@ -214,26 +190,21 @@ void session_free_tcp_segment(struct session *sess, struct tcp_segment *seg)
return; return;
} }
struct tcp_half *half = NULL; enum session_dir dir = session_get_current_dir(sess);
if (session_get_cur_dir(sess) == SESSION_DIR_C2S) struct tcp_half *half = &sess->tcp_halfs[dir];
{
half = &sess->tcp_pcb.c2s;
}
else
{
half = &sess->tcp_pcb.s2c;
}
if (seg == &half->order) if (seg == &half->in_order)
{ {
half->order.data = NULL; half->in_order.data = NULL;
half->order.len = 0; half->in_order.len = 0;
return; return;
} }
else else
{ {
session_inc_stat(sess, dir, STAT_TCP_SEGS_RELEASED, 1);
session_inc_stat(sess, dir, STAT_TCP_PLDS_RELEASED, seg->len);
sess->mgr_stat->nr_tcp_seg_released++; sess->mgr_stat->nr_tcp_seg_released++;
half->nr_tcp_seg_released++;
tcp_segment_free(seg); tcp_segment_free(seg);
} }
} }
@@ -412,36 +383,26 @@ const char *session_dir_to_str(enum session_dir dir)
} }
} }
void tcp_half_dump(const struct tcp_half *half) void tcp_flags_to_str(uint8_t flags, char *buffer, size_t len)
{ {
char buffer[32] = {0};
int used = 0; int used = 0;
if (half->flags & TH_SYN) if (flags & TH_SYN)
{ {
used += snprintf(buffer + used, sizeof(buffer) - used, "SYN "); used += snprintf(buffer + used, len - used, "SYN ");
} }
if (half->flags & TH_ACK) if (flags & TH_ACK)
{ {
used += snprintf(buffer + used, sizeof(buffer) - used, "ACK "); used += snprintf(buffer + used, len - used, "ACK ");
} }
if (half->flags & TH_FIN) if (flags & TH_FIN)
{ {
used += snprintf(buffer + used, sizeof(buffer) - used, "FIN "); used += snprintf(buffer + used, len - used, "FIN ");
} }
if (half->flags & TH_RST) if (flags & TH_RST)
{ {
used += snprintf(buffer + used, sizeof(buffer) - used, "RST "); used += snprintf(buffer + used, len - used, "RST ");
} }
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) void session_dump(struct session *sess)
@@ -456,24 +417,15 @@ void session_dump(struct session *sess)
printf("session type : %s\n", session_type_to_str(session_get_type(sess))); printf("session type : %s\n", session_type_to_str(session_get_type(sess)));
printf("session dup traffic : %d\n", session_has_dup_traffic(sess)); printf("session dup traffic : %d\n", session_has_dup_traffic(sess));
printf("session closing reason : %s\n", closing_reason_to_str(session_get_closing_reason(sess))); printf("session closing reason : %s\n", closing_reason_to_str(session_get_closing_reason(sess)));
printf("session C2S packets : %" PRIu64 "\n", session_get_metric(sess, SESSION_METRIC_C2S_PACKETS));
printf("session C2S bytes : %" PRIu64 "\n", session_get_metric(sess, SESSION_METRIC_C2S_BYTES));
printf("session S2C packets : %" PRIu64 "\n", session_get_metric(sess, SESSION_METRIC_S2C_PACKETS));
printf("session S2C bytes : %" PRIu64 "\n", session_get_metric(sess, SESSION_METRIC_S2C_BYTES));
printf("session new time : %" PRIu64 "\n", session_get_timestamp(sess, SESSION_TIMESTAMP_NEW)); printf("session new time : %" PRIu64 "\n", session_get_timestamp(sess, SESSION_TIMESTAMP_NEW));
printf("session last time : %" PRIu64 "\n", session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); printf("session last time : %" PRIu64 "\n", session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
printf("session current packet ptr : %p\n", (void *)session_get_packet(sess, SESSION_PACKET_CURRENT)); printf("session current packet dir : %s\n", session_dir_to_str(session_get_current_dir(sess)));
printf("session current packet dir : %s\n", session_dir_to_str(session_get_cur_dir(sess)));
// TODO session stat
printf("session ex data:\n"); printf("session ex data:\n");
for (uint8_t i = 0; i < g_ex_manager.count; i++) for (uint8_t i = 0; i < g_ex_manager.count; i++)
{ {
printf(" ex_idx: %d, ex_key: %s, ex_data: %p\n", i, g_ex_manager.schemas[i].key, sess->ex_data[i]); printf(" ex_idx: %d, ex_key: %s, ex_data: %p\n", i, g_ex_manager.schemas[i].key, sess->ex_data[i]);
} }
if (session_get_type(sess) == SESSION_TYPE_TCP)
{
printf("session TCP C2S:\n");
tcp_half_dump(&sess->tcp_pcb.c2s);
printf("session TCP S2C:\n");
tcp_half_dump(&sess->tcp_pcb.s2c);
}
} }

113
src/session/session.h
View File

@@ -37,9 +37,10 @@ enum session_type
enum session_dir enum session_dir
{ {
SESSION_DIR_NONE = 0x0, SESSION_DIR_NONE = -1,
SESSION_DIR_C2S = 0x1, SESSION_DIR_C2S = 0,
SESSION_DIR_S2C = 0x2, SESSION_DIR_S2C = 1,
MAX_DIR = 2,
}; };
enum closing_reason enum closing_reason
@@ -52,23 +53,64 @@ enum closing_reason
CLOSING_BY_SERVER_RST = 0x6, CLOSING_BY_SERVER_RST = 0x6,
}; };
enum session_metric_index enum session_stat
{ {
SESSION_METRIC_C2S_BYTES, // raw packet
SESSION_METRIC_S2C_BYTES, STAT_RAW_PKTS_RX,
SESSION_METRIC_C2S_PACKETS, STAT_RAW_BYTES_RX,
SESSION_METRIC_S2C_PACKETS,
MAX_METRIC, STAT_RAW_PKTS_TX,
STAT_RAW_BYTES_TX,
STAT_RAW_PKTS_DROP,
STAT_RAW_BYTES_DROP,
// control packet
STAT_CTRL_PKTS_RX, // TODO
STAT_CTRL_BYTES_RX, // TODO
STAT_CTRL_PKTS_TX,
STAT_CTRL_BYTES_TX,
STAT_CTRL_PKTS_DROP,
STAT_CTRL_BYTES_DROP,
// TCP segment
STAT_TCP_SEGS_RX,
STAT_TCP_PLDS_RX,
STAT_TCP_SEGS_EXPIRED,
STAT_TCP_PLDS_EXPIRED,
STAT_TCP_SEGS_OVERLAP,
STAT_TCP_PLDS_OVERLAP,
STAT_TCP_SEGS_NOSPACE,
STAT_TCP_PLDS_NOSPACE,
STAT_TCP_SEGS_INORDER,
STAT_TCP_PLDS_INORDER,
STAT_TCP_SEGS_REORDERED,
STAT_TCP_PLDS_REORDERED,
STAT_TCP_SEGS_BUFFERED,
STAT_TCP_PLDS_BUFFERED,
STAT_TCP_SEGS_RELEASED,
STAT_TCP_PLDS_RELEASED,
MAX_STAT,
}; };
enum session_timestamp_index enum session_timestamp
{ {
SESSION_TIMESTAMP_NEW, SESSION_TIMESTAMP_NEW,
SESSION_TIMESTAMP_LAST, SESSION_TIMESTAMP_LAST,
MAX_TIMESTAMP, MAX_TIMESTAMP,
}; };
enum session_packet_index enum session_packet
{ {
SESSION_PACKET_C2S_1ST, SESSION_PACKET_C2S_1ST,
SESSION_PACKET_S2C_1ST, SESSION_PACKET_S2C_1ST,
@@ -79,36 +121,17 @@ enum session_packet_index
struct tcp_half struct tcp_half
{ {
struct tcp_reassembly *assembler; struct tcp_reassembly *assembler;
struct tcp_segment order; struct tcp_segment in_order;
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_tcp_seg_inorder;
uint64_t nr_tcp_seg_reorded;
uint64_t nr_tcp_seg_buffered;
uint64_t nr_tcp_seg_released;
uint32_t seq; uint32_t seq;
uint32_t ack; uint32_t ack;
uint8_t flags; uint8_t flags;
}; };
// the TCP protocol control block
struct tcp_pcb
{
uint8_t tcp_reassembly_enable;
struct tcp_half c2s;
struct tcp_half s2c;
};
struct session struct session
{ {
uint64_t id; uint64_t id;
uint64_t metrics[MAX_METRIC]; uint64_t stats[MAX_DIR][MAX_STAT];
uint64_t timestamps[MAX_TIMESTAMP]; uint64_t timestamps[MAX_TIMESTAMP];
enum session_dir tuple_dir; enum session_dir tuple_dir;
@@ -123,14 +146,15 @@ struct session
struct list_head lru; // used for lru queue struct list_head lru; // used for lru queue
struct list_head free; // used for free queue struct list_head free; // used for free queue
struct list_head evicte; // used for evicte queue struct list_head evicte; // used for evicte queue
const struct packet *packets[MAX_PACKETS]; const struct packet *first_pkt[MAX_DIR]; // per direction
const struct packet *curr_pkt;
UT_hash_handle hh; // used for hash table UT_hash_handle hh; // used for hash table
void *ex_data[EX_DATA_MAX_COUNT]; void *ex_data[EX_DATA_MAX_COUNT];
void *user_data; void *user_data;
struct tcp_pcb tcp_pcb; struct tcp_half tcp_halfs[MAX_DIR];
struct session_manager_stat *mgr_stat; struct session_manager_stat *mgr_stat;
}; };
@@ -149,8 +173,8 @@ const struct tuple6 *session_get_tuple(const struct session *sess);
void session_set_tuple_dir(struct session *sess, enum session_dir dir); void session_set_tuple_dir(struct session *sess, enum session_dir dir);
enum session_dir session_get_tuple_dir(const struct session *sess); enum session_dir session_get_tuple_dir(const struct session *sess);
void session_set_cur_dir(struct session *sess, enum session_dir dir); void session_set_current_dir(struct session *sess, enum session_dir dir);
enum session_dir session_get_cur_dir(const struct session *sess); enum session_dir session_get_current_dir(const struct session *sess);
void session_set_state(struct session *sess, enum session_state state); void session_set_state(struct session *sess, enum session_state state);
enum session_state session_get_state(const struct session *sess); enum session_state session_get_state(const struct session *sess);
@@ -164,16 +188,17 @@ int session_has_dup_traffic(const struct session *sess);
void session_set_closing_reason(struct session *sess, enum closing_reason reason); void session_set_closing_reason(struct session *sess, enum closing_reason reason);
enum closing_reason session_get_closing_reason(const struct session *sess); enum closing_reason session_get_closing_reason(const struct session *sess);
void session_inc_metric(struct session *sess, enum session_metric_index idx, uint64_t val); void session_inc_stat(struct session *sess, enum session_dir dir, enum session_stat stat, uint64_t val);
void session_set_metric(struct session *sess, enum session_metric_index idx, uint64_t val); uint64_t session_get_stat(const struct session *sess, enum session_dir dir, enum session_stat stat);
uint64_t session_get_metric(const struct session *sess, enum session_metric_index idx);
void session_set_timestamp(struct session *sess, enum session_timestamp_index idx, uint64_t timestamp); void session_set_timestamp(struct session *sess, enum session_timestamp idx, uint64_t timestamp);
uint64_t session_get_timestamp(const struct session *sess, enum session_timestamp_index idx); uint64_t session_get_timestamp(const struct session *sess, enum session_timestamp idx);
void session_set_packet(struct session *sess, enum session_packet_index idx, const struct packet *pkt); void session_set_1st_packet(struct session *sess, enum session_dir dir, const struct packet *pkt);
void session_clean_packet(struct session *sess, enum session_packet_index idx); const struct packet *session_get_1st_packet(const struct session *sess, enum session_dir dir);
const struct packet *session_get_packet(const struct session *sess, enum session_packet_index idx);
void session_set_current_packet(struct session *sess, const struct packet *pkt);
const struct packet *session_get_current_packet(const struct session *sess);
void session_set_user_data(struct session *sess, void *user_data); void session_set_user_data(struct session *sess, void *user_data);
void *session_get_user_data(const struct session *sess); void *session_get_user_data(const struct session *sess);

363
src/session/session_manager.cpp
View File

@@ -31,77 +31,68 @@ struct session_manager
#define EVICTE_SESSION_BURST (RX_BURST_MAX) #define EVICTE_SESSION_BURST (RX_BURST_MAX)
/****************************************************************************** /******************************************************************************
* Stat * Session Manager Stat
******************************************************************************/ ******************************************************************************/
#define NR_SESS_STAT_INC(stat, state, type) \ #define SESS_MGR_STAT_INC(stat, state, proto) \
{ \ { \
switch ((state)) \ switch ((state)) \
{ \ { \
case SESSION_STATE_OPENING: \ case SESSION_STATE_OPENING: \
(stat)->nr_##type##_sess_opening++; \ (stat)->nr_##proto##_sess_opening++; \
break; \ break; \
case SESSION_STATE_ACTIVE: \ case SESSION_STATE_ACTIVE: \
(stat)->nr_##type##_sess_active++; \ (stat)->nr_##proto##_sess_active++; \
break; \ break; \
case SESSION_STATE_CLOSING: \ case SESSION_STATE_CLOSING: \
(stat)->nr_##type##_sess_closing++; \ (stat)->nr_##proto##_sess_closing++; \
break; \ break; \
case SESSION_STATE_DISCARD: \ case SESSION_STATE_DISCARD: \
(stat)->nr_##type##_sess_discard++; \ (stat)->nr_##proto##_sess_discard++; \
break; \ break; \
case SESSION_STATE_CLOSED: \ case SESSION_STATE_CLOSED: \
(stat)->nr_##type##_sess_closed++; \ (stat)->nr_##proto##_sess_closed++; \
break; \ break; \
default: \ default: \
break; \ break; \
} \ } \
} }
#define NR_SESS_STAT_DEC(stat, state, type) \ #define SESS_MGR_STAT_DEC(stat, state, proto) \
{ \ { \
switch ((state)) \ switch ((state)) \
{ \ { \
case SESSION_STATE_OPENING: \ case SESSION_STATE_OPENING: \
(stat)->nr_##type##_sess_opening--; \ (stat)->nr_##proto##_sess_opening--; \
break; \ break; \
case SESSION_STATE_ACTIVE: \ case SESSION_STATE_ACTIVE: \
(stat)->nr_##type##_sess_active--; \ (stat)->nr_##proto##_sess_active--; \
break; \ break; \
case SESSION_STATE_CLOSING: \ case SESSION_STATE_CLOSING: \
(stat)->nr_##type##_sess_closing--; \ (stat)->nr_##proto##_sess_closing--; \
break; \ break; \
case SESSION_STATE_DISCARD: \ case SESSION_STATE_DISCARD: \
(stat)->nr_##type##_sess_discard--; \ (stat)->nr_##proto##_sess_discard--; \
break; \ break; \
case SESSION_STATE_CLOSED: \ case SESSION_STATE_CLOSED: \
(stat)->nr_##type##_sess_closed--; \ (stat)->nr_##proto##_sess_closed--; \
break; \ break; \
default: \ default: \
break; \ break; \
} \ } \
} }
#define NR_SESS_STAT_UPDATE(stat, curr, next, type) \ #define SESS_MGR_STAT_UPDATE(stat, curr, next, proto) \
{ \ { \
if (curr != next) \ if (curr != next) \
{ \ { \
NR_SESS_STAT_DEC(stat, curr, type); \ SESS_MGR_STAT_DEC(stat, curr, proto); \
NR_SESS_STAT_INC(stat, next, type); \ SESS_MGR_STAT_INC(stat, next, proto); \
} \ } \
} }
#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 * Session Manager Options
******************************************************************************/ ******************************************************************************/
static int check_options(const struct session_manager_options *opts) static int check_options(const struct session_manager_options *opts)
@@ -230,7 +221,7 @@ static int check_options(const struct session_manager_options *opts)
} }
/****************************************************************************** /******************************************************************************
* TCP protocol control block * TCP
******************************************************************************/ ******************************************************************************/
/* /*
@@ -243,55 +234,56 @@ static inline bool before(uint32_t seq1, uint32_t seq2)
return (int32_t)(seq1 - seq2) < 0; return (int32_t)(seq1 - seq2) < 0;
} }
static void tcp_pcb_clean(struct tcp_pcb *pcb) static void tcp_clean(struct session *sess)
{ {
if (pcb && pcb->tcp_reassembly_enable) tcp_reassembly_free(sess->tcp_halfs[SESSION_DIR_C2S].assembler);
{ tcp_reassembly_free(sess->tcp_halfs[SESSION_DIR_S2C].assembler);
tcp_reassembly_free(pcb->c2s.assembler);
tcp_reassembly_free(pcb->s2c.assembler);
}
} }
static int tcp_pcb_init(struct tcp_pcb *pcb, uint8_t tcp_reassembly_enable, uint64_t tcp_reassembly_max_timeout, uint64_t tcp_reassembly_max_segments) static int tcp_init(struct session *sess, uint8_t tcp_reassembly_enable, uint64_t tcp_reassembly_max_timeout, uint64_t tcp_reassembly_max_segments)
{ {
pcb->tcp_reassembly_enable = tcp_reassembly_enable; if (!tcp_reassembly_enable)
if (pcb->tcp_reassembly_enable == 0)
{ {
return 0; return 0;
} }
pcb->c2s.assembler = tcp_reassembly_new(tcp_reassembly_max_timeout, tcp_reassembly_max_segments); sess->tcp_halfs[SESSION_DIR_C2S].assembler = tcp_reassembly_new(tcp_reassembly_max_timeout, tcp_reassembly_max_segments);
pcb->s2c.assembler = tcp_reassembly_new(tcp_reassembly_max_timeout, tcp_reassembly_max_segments); sess->tcp_halfs[SESSION_DIR_S2C].assembler = tcp_reassembly_new(tcp_reassembly_max_timeout, tcp_reassembly_max_segments);
if (pcb->c2s.assembler == NULL || pcb->s2c.assembler == NULL) if (sess->tcp_halfs[SESSION_DIR_C2S].assembler == NULL || sess->tcp_halfs[SESSION_DIR_S2C].assembler == NULL)
{ {
tcp_pcb_clean(pcb); tcp_clean(sess);
return -1; return -1;
} }
return 0; return 0;
} }
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) static void tcp_update(struct session_manager *mgr, struct session *sess, enum session_dir dir, const struct pkt_layer *tcp_layer, uint64_t now)
{ {
struct tcp_segment *seg; struct tcp_segment *seg;
struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr; struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr;
struct tcp_half *half = (dir == SESSION_DIR_C2S) ? &pcb->c2s : &pcb->s2c; struct tcp_half *half = &sess->tcp_halfs[dir];
uint8_t flags = tcp_hdr_get_flags(hdr); uint8_t flags = tcp_hdr_get_flags(hdr);
uint16_t len = tcp_layer->pld_len;
half->flags |= flags; half->flags |= flags;
half->seq = tcp_hdr_get_seq(hdr); half->seq = tcp_hdr_get_seq(hdr);
half->ack = tcp_hdr_get_ack(hdr); half->ack = tcp_hdr_get_ack(hdr);
if (pcb->tcp_reassembly_enable == 0) if (!mgr->opts.tcp_reassembly_enable)
{ {
if (tcp_layer->pld_len) if (len)
{ {
half->nr_tcp_seg_received++; session_inc_stat(sess, dir, STAT_TCP_SEGS_RX, 1);
half->nr_tcp_seg_inorder++; session_inc_stat(sess, dir, STAT_TCP_PLDS_RX, len);
stat->nr_tcp_seg_received++; mgr->stat.nr_tcp_seg_received++;
stat->nr_tcp_seg_inorder++;
half->order.data = tcp_layer->pld_ptr; session_inc_stat(sess, dir, STAT_TCP_SEGS_INORDER, 1);
half->order.len = tcp_layer->pld_len; session_inc_stat(sess, dir, STAT_TCP_PLDS_INORDER, len);
mgr->stat.nr_tcp_seg_inorder++;
half->in_order.data = tcp_layer->pld_ptr;
half->in_order.len = len;
} }
return; return;
} }
@@ -304,51 +296,63 @@ static void tcp_pcb_update(struct session_manager_stat *stat, struct tcp_pcb *pc
seg = tcp_reassembly_expire(half->assembler, now); seg = tcp_reassembly_expire(half->assembler, now);
if (seg) if (seg)
{ {
half->nr_tcp_seg_expired++; session_inc_stat(sess, dir, STAT_TCP_SEGS_EXPIRED, 1);
half->nr_tcp_seg_released++; session_inc_stat(sess, dir, STAT_TCP_PLDS_EXPIRED, seg->len);
stat->nr_tcp_seg_expired++; mgr->stat.nr_tcp_seg_expired++;
stat->nr_tcp_seg_released++;
session_inc_stat(sess, dir, STAT_TCP_SEGS_RELEASED, 1);
session_inc_stat(sess, dir, STAT_TCP_PLDS_RELEASED, seg->len);
mgr->stat.nr_tcp_seg_released++;
tcp_segment_free(seg); tcp_segment_free(seg);
} }
if (tcp_layer->pld_len) if (len)
{ {
half->nr_tcp_seg_received++; session_inc_stat(sess, dir, STAT_TCP_SEGS_RX, 1);
stat->nr_tcp_seg_received++; session_inc_stat(sess, dir, STAT_TCP_PLDS_RX, len);
mgr->stat.nr_tcp_seg_received++;
uint32_t rcv_nxt = tcp_reassembly_get_recv_next(half->assembler); uint32_t rcv_nxt = tcp_reassembly_get_recv_next(half->assembler);
if (half->seq == rcv_nxt) if (half->seq == rcv_nxt)
{ {
half->nr_tcp_seg_inorder++; session_inc_stat(sess, dir, STAT_TCP_SEGS_INORDER, 1);
stat->nr_tcp_seg_inorder++; session_inc_stat(sess, dir, STAT_TCP_PLDS_INORDER, len);
mgr->stat.nr_tcp_seg_inorder++;
half->order.data = tcp_layer->pld_ptr; half->in_order.data = tcp_layer->pld_ptr;
half->order.len = tcp_layer->pld_len; half->in_order.len = len;
tcp_reassembly_inc_recv_next(half->assembler, tcp_layer->pld_len); tcp_reassembly_inc_recv_next(half->assembler, len);
} }
else if (before(half->seq, rcv_nxt)) else if (before(half->seq, rcv_nxt))
{ {
half->nr_tcp_seg_overlap++; session_inc_stat(sess, dir, STAT_TCP_SEGS_OVERLAP, 1);
stat->nr_tcp_seg_overlap++; session_inc_stat(sess, dir, STAT_TCP_PLDS_OVERLAP, len);
mgr->stat.nr_tcp_seg_overlap++;
} }
else if ((seg = tcp_segment_new(half->seq, tcp_layer->pld_ptr, tcp_layer->pld_len))) else if ((seg = tcp_segment_new(half->seq, tcp_layer->pld_ptr, len)))
{ {
switch (tcp_reassembly_push(half->assembler, seg, now)) switch (tcp_reassembly_push(half->assembler, seg, now))
{ {
case -1: case -1:
half->nr_tcp_seg_no_space++; session_inc_stat(sess, dir, STAT_TCP_SEGS_NOSPACE, 1);
stat->nr_tcp_seg_no_space++; session_inc_stat(sess, dir, STAT_TCP_PLDS_NOSPACE, len);
mgr->stat.nr_tcp_seg_no_space++;
tcp_segment_free(seg); tcp_segment_free(seg);
break; break;
case 0: case 0:
half->nr_tcp_seg_buffered++; session_inc_stat(sess, dir, STAT_TCP_SEGS_BUFFERED, 1);
stat->nr_tcp_seg_buffered++; session_inc_stat(sess, dir, STAT_TCP_PLDS_BUFFERED, len);
mgr->stat.nr_tcp_seg_buffered++;
break; break;
case 1: case 1:
half->nr_tcp_seg_buffered++; session_inc_stat(sess, dir, STAT_TCP_SEGS_OVERLAP, 1);
half->nr_tcp_seg_overlap++; session_inc_stat(sess, dir, STAT_TCP_PLDS_OVERLAP, len);
stat->nr_tcp_seg_buffered++; mgr->stat.nr_tcp_seg_overlap++;
stat->nr_tcp_seg_overlap++;
session_inc_stat(sess, dir, STAT_TCP_SEGS_BUFFERED, 1);
session_inc_stat(sess, dir, STAT_TCP_PLDS_BUFFERED, len);
mgr->stat.nr_tcp_seg_buffered++;
break; break;
default: default:
assert(0); assert(0);
@@ -357,8 +361,9 @@ static void tcp_pcb_update(struct session_manager_stat *stat, struct tcp_pcb *pc
} }
else else
{ {
half->nr_tcp_seg_no_space++; session_inc_stat(sess, dir, STAT_TCP_SEGS_NOSPACE, 1);
stat->nr_tcp_seg_no_space++; session_inc_stat(sess, dir, STAT_TCP_PLDS_NOSPACE, len);
mgr->stat.nr_tcp_seg_no_space++;
} }
} }
} }
@@ -401,47 +406,26 @@ static enum session_dir identify_direction_by_history(const struct session *sess
* Session Filter * Session Filter
******************************************************************************/ ******************************************************************************/
#define MAX_FILTER_NUM_PER_STAGE 4 // on new session
enum filter_stage static int tcp_overload_bypass(struct session_manager *mgr, const struct tuple6 *key, uint64_t now)
{ {
FILTER_STAGE_PRE_NEW_SESS, if (key->ip_proto == IPPROTO_TCP && mgr->stat.nr_tcp_sess_used >= mgr->opts.max_tcp_session_num)
FILTER_STAGE_PRE_UPDATE_SESS,
MAX_FILTER_STAGE,
};
// return 1: bypass
// return 0: not bypass
typedef int filter(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key, uint64_t now);
// on pre new session
static int session_manager_self_protection(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key, uint64_t now)
{ {
struct session_manager_stat *stat = &mgr->stat; mgr->stat.nr_tcp_pkts_bypass_no_space++;
switch (key->ip_proto)
{
case IPPROTO_TCP:
if (stat->nr_tcp_sess_used >= mgr->opts.max_tcp_session_num)
{
stat->nr_tcp_pkts_bypass_no_space++;
return 1; return 1;
} }
break;
case IPPROTO_UDP:
if (stat->nr_udp_sess_used >= mgr->opts.max_udp_session_num)
{
stat->nr_udp_pkts_bypass_no_space++;
return 1;
}
break;
default:
break;
}
return 0; return 0;
} }
static int udp_overload_bypass(struct session_manager *mgr, const struct tuple6 *key, uint64_t now)
// on pre new session {
static int session_manager_filter_evicted_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key, uint64_t now) if (key->ip_proto == IPPROTO_UDP && mgr->stat.nr_udp_sess_used >= mgr->opts.max_udp_session_num)
{
mgr->stat.nr_udp_pkts_bypass_no_space++;
return 1;
}
return 0;
}
static int evicted_session_bypass(struct session_manager *mgr, const struct tuple6 *key, uint64_t now)
{ {
if (mgr->opts.evicted_session_filter_enable && evicted_session_filter_lookup(mgr->evicte_sess_filter, key, now)) if (mgr->opts.evicted_session_filter_enable && evicted_session_filter_lookup(mgr->evicte_sess_filter, key, now))
{ {
@@ -451,9 +435,8 @@ static int session_manager_filter_evicted_session(struct session_manager *mgr, s
return 0; return 0;
} }
// on update session
// on pre update session static int duplicated_packet_bypass(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key, uint64_t now)
static int session_manager_filter_duplicated_packet(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key, uint64_t now)
{ {
if (mgr->opts.duplicated_packet_filter_enable == 0) if (mgr->opts.duplicated_packet_filter_enable == 0)
{ {
@@ -461,9 +444,7 @@ static int session_manager_filter_duplicated_packet(struct session_manager *mgr,
} }
enum session_dir dir = identify_direction_by_history(sess, key); enum session_dir dir = identify_direction_by_history(sess, key);
if ((dir == SESSION_DIR_C2S && session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) < 3) || if (session_get_stat(sess, dir, STAT_RAW_PKTS_RX) < 3 || session_has_dup_traffic(sess))
(dir == SESSION_DIR_S2C && session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) < 3) ||
(session_has_dup_traffic(sess) == 1))
{ {
if (duplicated_packet_filter_lookup(mgr->dup_pkt_filter, pkt, now)) if (duplicated_packet_filter_lookup(mgr->dup_pkt_filter, pkt, now))
{ {
@@ -481,49 +462,6 @@ static int session_manager_filter_duplicated_packet(struct session_manager *mgr,
return 0; return 0;
} }
filter *smf[MAX_FILTER_STAGE][MAX_FILTER_NUM_PER_STAGE];
static void session_filter_init()
{
for (int i = 0; i < MAX_FILTER_STAGE; i++)
{
for (int j = 0; j < MAX_FILTER_NUM_PER_STAGE; j++)
{
smf[i][j] = NULL;
}
}
smf[FILTER_STAGE_PRE_NEW_SESS][0] = session_manager_self_protection;
smf[FILTER_STAGE_PRE_NEW_SESS][1] = session_manager_filter_evicted_session;
smf[FILTER_STAGE_PRE_NEW_SESS][2] = NULL;
smf[FILTER_STAGE_PRE_UPDATE_SESS][0] = session_manager_filter_duplicated_packet;
smf[FILTER_STAGE_PRE_UPDATE_SESS][1] = NULL;
}
// return 1: bypass packet
// return 0: not bypass packet
static int session_filter_run(struct session_manager *mgr, enum filter_stage stage, struct session *sess, const struct packet *pkt, const struct tuple6 *key, uint64_t now)
{
filter **list = smf[stage];
for (int i = 0; i < MAX_FILTER_NUM_PER_STAGE; i++)
{
if (list[i])
{
if (list[i](mgr, sess, pkt, key, now))
{
return 1;
}
}
else
{
break;
}
}
return 0;
}
/****************************************************************************** /******************************************************************************
* Session Manager * Session Manager
******************************************************************************/ ******************************************************************************/
@@ -549,20 +487,16 @@ static void session_update(struct session *sess, enum session_state next_state,
} }
} }
if (dir == SESSION_DIR_C2S) session_inc_stat(sess, dir, STAT_RAW_PKTS_RX, 1);
session_inc_stat(sess, dir, STAT_RAW_BYTES_RX, packet_get_len(pkt));
if (!session_get_1st_packet(sess, dir))
{ {
session_inc_metric(sess, SESSION_METRIC_C2S_PACKETS, 1); session_set_1st_packet(sess, dir, pkt);
session_inc_metric(sess, SESSION_METRIC_C2S_BYTES, packet_get_len(pkt));
session_set_packet(sess, SESSION_PACKET_C2S_1ST, pkt);
} }
else
{ session_set_current_packet(sess, pkt);
session_inc_metric(sess, SESSION_METRIC_S2C_PACKETS, 1); session_set_current_dir(sess, dir);
session_inc_metric(sess, SESSION_METRIC_S2C_BYTES, packet_get_len(pkt));
session_set_packet(sess, SESSION_PACKET_S2C_1ST, pkt);
}
session_set_packet(sess, SESSION_PACKET_CURRENT, pkt);
session_set_cur_dir(sess, dir);
session_set_timestamp(sess, SESSION_TIMESTAMP_LAST, now); session_set_timestamp(sess, SESSION_TIMESTAMP_LAST, now);
session_set_state(sess, next_state); session_set_state(sess, next_state);
} }
@@ -579,9 +513,11 @@ static void session_manager_evicte_session(struct session_manager *mgr, struct s
enum session_state next_state = session_transition_run(curr_state, LRU_EVICT); enum session_state next_state = session_transition_run(curr_state, LRU_EVICT);
session_transition_log(sess, curr_state, next_state, LRU_EVICT); session_transition_log(sess, curr_state, next_state, LRU_EVICT);
session_set_state(sess, next_state); session_set_state(sess, next_state);
if (!session_get_closing_reason(sess))
session_timer_del(mgr->sess_timer, sess); {
session_set_closing_reason(sess, CLOSING_BY_EVICTED); session_set_closing_reason(sess, CLOSING_BY_EVICTED);
}
session_timer_del(mgr->sess_timer, sess);
list_add_tail(&sess->evicte, &mgr->evicte_queue); list_add_tail(&sess->evicte, &mgr->evicte_queue);
switch (session_get_type(sess)) switch (session_get_type(sess))
@@ -589,7 +525,7 @@ static void session_manager_evicte_session(struct session_manager *mgr, struct s
case SESSION_TYPE_TCP: case SESSION_TYPE_TCP:
SESSION_LOG_DEBUG("evicte tcp old session: %lu", session_get_id(sess)); SESSION_LOG_DEBUG("evicte tcp old session: %lu", session_get_id(sess));
session_table_del(mgr->tcp_sess_table, session_get_tuple(sess)); session_table_del(mgr->tcp_sess_table, session_get_tuple(sess));
NR_TCP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state); SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, tcp);
mgr->stat.nr_tcp_sess_evicted++; mgr->stat.nr_tcp_sess_evicted++;
break; break;
case SESSION_TYPE_UDP: case SESSION_TYPE_UDP:
@@ -599,7 +535,7 @@ static void session_manager_evicte_session(struct session_manager *mgr, struct s
{ {
evicted_session_filter_add(mgr->evicte_sess_filter, session_get_tuple(sess), now); evicted_session_filter_add(mgr->evicte_sess_filter, session_get_tuple(sess), now);
} }
NR_UDP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state); SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, udp);
mgr->stat.nr_udp_sess_evicted++; mgr->stat.nr_udp_sess_evicted++;
break; break;
default: default:
@@ -637,13 +573,13 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
sess->mgr_stat = &mgr->stat; sess->mgr_stat = &mgr->stat;
session_set_id(sess, id_generator_alloc()); 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) if (tcp_init(sess, mgr->opts.tcp_reassembly_enable, mgr->opts.tcp_reassembly_max_timeout, mgr->opts.tcp_reassembly_max_segments) == -1)
{ {
assert(0); assert(0);
session_pool_push(mgr->sess_pool, sess); session_pool_push(mgr->sess_pool, sess);
return NULL; return NULL;
} }
tcp_pcb_update(&mgr->stat, &sess->tcp_pcb, dir, tcp_layer, now); tcp_update(mgr, sess, dir, tcp_layer, now);
enum session_state next_state = session_transition_run(SESSION_STATE_INIT, TCP_SYN); enum session_state next_state = session_transition_run(SESSION_STATE_INIT, TCP_SYN);
session_update(sess, next_state, pkt, key, dir, now); session_update(sess, next_state, pkt, key, dir, now);
@@ -653,13 +589,12 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
session_timer_update(mgr->sess_timer, sess, now + timeout); session_timer_update(mgr->sess_timer, sess, now + timeout);
session_table_add(mgr->tcp_sess_table, key, sess); session_table_add(mgr->tcp_sess_table, key, sess);
uint64_t curr_dir_pkts = (dir == SESSION_DIR_C2S) ? session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) : session_get_metric(sess, SESSION_METRIC_S2C_PACKETS); if (session_get_stat(sess, dir, STAT_RAW_PKTS_RX) < 3 && mgr->opts.duplicated_packet_filter_enable)
if (curr_dir_pkts < 3 && mgr->opts.duplicated_packet_filter_enable)
{ {
duplicated_packet_filter_add(mgr->dup_pkt_filter, pkt, now); duplicated_packet_filter_add(mgr->dup_pkt_filter, pkt, now);
} }
NR_TCP_SESS_STAT_INC(&mgr->stat, next_state); SESS_MGR_STAT_INC(&mgr->stat, next_state, tcp);
mgr->stat.nr_tcp_sess_used++; mgr->stat.nr_tcp_sess_used++;
return sess; return sess;
@@ -692,7 +627,7 @@ static struct session *session_manager_new_udp_session(struct session_manager *m
session_timer_update(mgr->sess_timer, sess, now + mgr->opts.udp_data_timeout); session_timer_update(mgr->sess_timer, sess, now + mgr->opts.udp_data_timeout);
session_table_add(mgr->udp_sess_table, key, sess); session_table_add(mgr->udp_sess_table, key, sess);
NR_UDP_SESS_STAT_INC(&mgr->stat, next_state); SESS_MGR_STAT_INC(&mgr->stat, next_state, udp);
mgr->stat.nr_udp_sess_used++; mgr->stat.nr_udp_sess_used++;
return sess; return sess;
@@ -718,8 +653,8 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
session_update(sess, next_state, pkt, key, dir, now); session_update(sess, next_state, pkt, key, dir, now);
session_transition_log(sess, curr_state, next_state, inputs); session_transition_log(sess, curr_state, next_state, inputs);
// update tcp pcb // update tcp
tcp_pcb_update(&mgr->stat, &sess->tcp_pcb, dir, tcp_layer, now); tcp_update(mgr, sess, dir, tcp_layer, now);
if (mgr->opts.duplicated_packet_filter_enable) if (mgr->opts.duplicated_packet_filter_enable)
{ {
@@ -740,8 +675,8 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
} }
// update timeout // update timeout
struct tcp_half *curr = (dir == SESSION_DIR_C2S) ? &sess->tcp_pcb.c2s : &sess->tcp_pcb.s2c; struct tcp_half *curr = &sess->tcp_halfs[dir];
struct tcp_half *peer = (dir == SESSION_DIR_C2S) ? &sess->tcp_pcb.s2c : &sess->tcp_pcb.c2s; struct tcp_half *peer = &sess->tcp_halfs[(dir == SESSION_DIR_C2S ? SESSION_DIR_S2C : SESSION_DIR_C2S)];
uint64_t timeout = 0; uint64_t timeout = 0;
switch (next_state) switch (next_state)
{ {
@@ -783,7 +718,7 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
} }
session_timer_update(mgr->sess_timer, sess, now + timeout); session_timer_update(mgr->sess_timer, sess, now + timeout);
NR_TCP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state); SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, tcp);
return 0; return 0;
} }
@@ -797,7 +732,7 @@ static int session_manager_update_udp_session(struct session_manager *mgr, struc
session_transition_log(sess, curr_state, next_state, UDP_DATA); session_transition_log(sess, curr_state, next_state, UDP_DATA);
session_timer_update(mgr->sess_timer, sess, now + mgr->opts.udp_data_timeout); session_timer_update(mgr->sess_timer, sess, now + mgr->opts.udp_data_timeout);
NR_UDP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state); SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, udp);
return 0; return 0;
} }
@@ -830,7 +765,9 @@ struct session_manager *session_manager_new(struct session_manager_options *opts
} }
if (mgr->opts.evicted_session_filter_enable) if (mgr->opts.evicted_session_filter_enable)
{ {
mgr->evicte_sess_filter = evicted_session_filter_new(mgr->opts.evicted_session_filter_capacity, mgr->opts.evicted_session_filter_timeout, mgr->opts.evicted_session_filter_error_rate, now); mgr->evicte_sess_filter = evicted_session_filter_new(mgr->opts.evicted_session_filter_capacity,
mgr->opts.evicted_session_filter_timeout,
mgr->opts.evicted_session_filter_error_rate, now);
if (mgr->evicte_sess_filter == NULL) if (mgr->evicte_sess_filter == NULL)
{ {
goto error; goto error;
@@ -838,7 +775,9 @@ struct session_manager *session_manager_new(struct session_manager_options *opts
} }
if (mgr->opts.duplicated_packet_filter_enable) if (mgr->opts.duplicated_packet_filter_enable)
{ {
mgr->dup_pkt_filter = duplicated_packet_filter_new(mgr->opts.duplicated_packet_filter_capacity, mgr->opts.duplicated_packet_filter_timeout, mgr->opts.duplicated_packet_filter_error_rate, now); mgr->dup_pkt_filter = duplicated_packet_filter_new(mgr->opts.duplicated_packet_filter_capacity,
mgr->opts.duplicated_packet_filter_timeout,
mgr->opts.duplicated_packet_filter_error_rate, now);
if (mgr->dup_pkt_filter == NULL) if (mgr->dup_pkt_filter == NULL)
{ {
goto error; goto error;
@@ -846,7 +785,6 @@ struct session_manager *session_manager_new(struct session_manager_options *opts
} }
INIT_LIST_HEAD(&mgr->evicte_queue); INIT_LIST_HEAD(&mgr->evicte_queue);
session_filter_init();
session_transition_init(); session_transition_init();
return mgr; return mgr;
@@ -902,15 +840,23 @@ struct session *session_manager_new_session(struct session_manager *mgr, const s
{ {
return NULL; return NULL;
} }
if (session_filter_run(mgr, FILTER_STAGE_PRE_NEW_SESS, NULL, pkt, &key, now))
{
return NULL;
}
switch (key.ip_proto) switch (key.ip_proto)
{ {
case IPPROTO_TCP: case IPPROTO_TCP:
if (tcp_overload_bypass(mgr, &key, now))
{
return NULL;
}
return session_manager_new_tcp_session(mgr, pkt, &key, now); return session_manager_new_tcp_session(mgr, pkt, &key, now);
case IPPROTO_UDP: case IPPROTO_UDP:
if (udp_overload_bypass(mgr, &key, now))
{
return NULL;
}
if (evicted_session_bypass(mgr, &key, now))
{
return NULL;
}
return session_manager_new_udp_session(mgr, pkt, &key, now); return session_manager_new_udp_session(mgr, pkt, &key, now);
default: default:
return NULL; return NULL;
@@ -927,24 +873,27 @@ void session_manager_free_session(struct session_manager *mgr, struct session *s
switch (session_get_type(sess)) switch (session_get_type(sess))
{ {
case SESSION_TYPE_TCP: case SESSION_TYPE_TCP:
tcp_pcb_clean(&sess->tcp_pcb); tcp_clean(sess);
session_table_del(mgr->tcp_sess_table, session_get_tuple(sess)); session_table_del(mgr->tcp_sess_table, session_get_tuple(sess));
NR_TCP_SESS_STAT_DEC(&mgr->stat, session_get_state(sess)); SESS_MGR_STAT_DEC(&mgr->stat, session_get_state(sess), tcp);
mgr->stat.nr_tcp_sess_used--; mgr->stat.nr_tcp_sess_used--;
break; break;
case SESSION_TYPE_UDP: case SESSION_TYPE_UDP:
session_table_del(mgr->udp_sess_table, session_get_tuple(sess)); session_table_del(mgr->udp_sess_table, session_get_tuple(sess));
NR_UDP_SESS_STAT_DEC(&mgr->stat, session_get_state(sess)); SESS_MGR_STAT_DEC(&mgr->stat, session_get_state(sess), udp);
mgr->stat.nr_udp_sess_used--; mgr->stat.nr_udp_sess_used--;
break; break;
default: default:
assert(0); assert(0);
break; break;
} }
session_clean_packet(sess, SESSION_PACKET_C2S_1ST);
session_clean_packet(sess, SESSION_PACKET_S2C_1ST); packet_free((struct packet *)session_get_1st_packet(sess, SESSION_DIR_C2S));
session_clean_packet(sess, SESSION_PACKET_CURRENT); packet_free((struct packet *)session_get_1st_packet(sess, SESSION_DIR_S2C));
session_set_cur_dir(sess, SESSION_DIR_NONE); session_set_1st_packet(sess, SESSION_DIR_C2S, NULL);
session_set_1st_packet(sess, SESSION_DIR_S2C, NULL);
session_set_current_packet(sess, NULL);
session_set_current_dir(sess, SESSION_DIR_NONE);
session_free_all_ex_data(sess); session_free_all_ex_data(sess);
session_pool_push(mgr->sess_pool, sess); session_pool_push(mgr->sess_pool, sess);
sess = NULL; sess = NULL;
@@ -976,13 +925,13 @@ int session_manager_update_session(struct session_manager *mgr, struct session *
{ {
return -1; return -1;
} }
if (session_filter_run(mgr, FILTER_STAGE_PRE_UPDATE_SESS, sess, pkt, &key, now))
{
return -1;
}
switch (session_get_type(sess)) switch (session_get_type(sess))
{ {
case SESSION_TYPE_TCP: case SESSION_TYPE_TCP:
if (duplicated_packet_bypass(mgr, sess, pkt, &key, now))
{
return -1;
}
return session_manager_update_tcp_session(mgr, sess, pkt, &key, now); return session_manager_update_tcp_session(mgr, sess, pkt, &key, now);
case SESSION_TYPE_UDP: case SESSION_TYPE_UDP:
return session_manager_update_udp_session(mgr, sess, pkt, &key, now); return session_manager_update_udp_session(mgr, sess, pkt, &key, now);
@@ -1006,11 +955,11 @@ struct session *session_manager_get_expired_session(struct session_manager *mgr,
{ {
case SESSION_TYPE_TCP: case SESSION_TYPE_TCP:
timeout = mgr->opts.tcp_data_timeout; timeout = mgr->opts.tcp_data_timeout;
NR_TCP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state); SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, tcp);
break; break;
case SESSION_TYPE_UDP: case SESSION_TYPE_UDP:
timeout = mgr->opts.udp_data_timeout; timeout = mgr->opts.udp_data_timeout;
NR_UDP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state); SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, udp);
break; break;
default: default:
assert(0); assert(0);

38
src/session/session_manager.h
View File

@@ -53,10 +53,6 @@ struct session_manager_options
struct session_manager_stat struct session_manager_stat
{ {
/******************************************************
* state count
******************************************************/
// TCP session // TCP session
uint64_t nr_tcp_sess_used; uint64_t nr_tcp_sess_used;
uint64_t nr_tcp_sess_opening; uint64_t nr_tcp_sess_opening;
@@ -73,30 +69,26 @@ struct session_manager_stat
uint64_t nr_udp_sess_discard; uint64_t nr_udp_sess_discard;
uint64_t nr_udp_sess_closed; uint64_t nr_udp_sess_closed;
/******************************************************
* sum count
******************************************************/
// Evicted session // Evicted session
uint64_t nr_tcp_sess_evicted; uint64_t nr_tcp_sess_evicted; // sum
uint64_t nr_udp_sess_evicted; uint64_t nr_udp_sess_evicted; // sum
// Packet // Packet
uint64_t nr_udp_pkts_bypass_no_space; uint64_t nr_udp_pkts_bypass_no_space; // sum
uint64_t nr_tcp_pkts_bypass_no_space; uint64_t nr_tcp_pkts_bypass_no_space; // sum
uint64_t nr_tcp_pkts_bypass_miss_sess; uint64_t nr_tcp_pkts_bypass_miss_sess; // sum
uint64_t nr_tcp_pkts_bypass_hit_dup; uint64_t nr_tcp_pkts_bypass_hit_dup; // sum
uint64_t nr_udp_pkts_bypass_hit_evc; uint64_t nr_udp_pkts_bypass_hit_evc; // sum
// TCP segments // TCP segments
uint64_t nr_tcp_seg_received; uint64_t nr_tcp_seg_received; // sum
uint64_t nr_tcp_seg_expired; uint64_t nr_tcp_seg_expired; // sum
uint64_t nr_tcp_seg_overlap; uint64_t nr_tcp_seg_overlap; // sum
uint64_t nr_tcp_seg_no_space; uint64_t nr_tcp_seg_no_space; // sum
uint64_t nr_tcp_seg_inorder; uint64_t nr_tcp_seg_inorder; // sum
uint64_t nr_tcp_seg_reorded; uint64_t nr_tcp_seg_reorded; // sum
uint64_t nr_tcp_seg_buffered; uint64_t nr_tcp_seg_buffered; // sum
uint64_t nr_tcp_seg_released; uint64_t nr_tcp_seg_released; // sum
}; };
struct session_manager; struct session_manager;

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

@@ -122,16 +122,16 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 145 + 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 145 + 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 3); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 3);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -210,16 +210,16 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 145 + 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 145 + 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 3); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 3);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) == NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) == NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -298,16 +298,16 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 145); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 145);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 3); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 3);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -428,16 +428,16 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 145 + 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 145 + 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 3); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 3);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) == NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) == NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -509,16 +509,16 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 145); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 145);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 3); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 3);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat

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

@@ -81,16 +81,16 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 1);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) == NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) == NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -160,16 +160,16 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 74); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 74);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 1);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) == NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) == NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -250,16 +250,16 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 74); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 74);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -351,16 +351,16 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 74); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 74);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 3); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 3);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -448,16 +448,16 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 78); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 78);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) == NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) == NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -546,16 +546,16 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 74 + 74); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 74 + 74);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) == NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) == NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -636,16 +636,16 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) == NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) == NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -726,16 +726,16 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 74 + 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 74 + 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) == NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) == NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat

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

@@ -77,16 +77,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 1);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) == NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) == NULL);
// S2C SYNACK Packet // S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -108,16 +108,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 74); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 74);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
// C2S ACK Packet // C2S ACK Packet
printf("\n=> Packet Parse: TCP C2S ACK packet\n"); printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -139,16 +139,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 74); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 74);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 3); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 3);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
// C2S REQ Packet // C2S REQ Packet
printf("\n=> Packet Parse: TCP C2S REQ packet\n"); printf("\n=> Packet Parse: TCP C2S REQ packet\n");
@@ -170,16 +170,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 66 + 145); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 66 + 145);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 74); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 74);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 4); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 4);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
// S2C ACK Packet // S2C ACK Packet
printf("\n=> Packet Parse: TCP S2C ACK packet\n"); printf("\n=> Packet Parse: TCP S2C ACK packet\n");
@@ -201,16 +201,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 66 + 145); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 66 + 145);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 74 + 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 74 + 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 5); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 5);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
// S2C HTTP Resp Packet1 // S2C HTTP Resp Packet1
printf("\n=> Packet Parse: TCP S2C Resp packet1\n"); printf("\n=> Packet Parse: TCP S2C Resp packet1\n");
@@ -232,16 +232,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 66 + 145); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 66 + 145);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 74 + 66 + 1354); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 74 + 66 + 1354);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1 + 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1 + 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 6); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 6);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
// S2C HTTP Resp Packet2 // S2C HTTP Resp Packet2
printf("\n=> Packet Parse: TCP S2C Resp packet2\n"); printf("\n=> Packet Parse: TCP S2C Resp packet2\n");
@@ -263,16 +263,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 66 + 145); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 66 + 145);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 74 + 66 + 1354 + 385); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 74 + 66 + 1354 + 385);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1 + 1 + 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 7); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 7);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
// C2S ACK Packet // C2S ACK Packet
printf("\n=> Packet Parse: TCP C2S ACK packet\n"); printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -294,16 +294,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 66 + 145 + 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 66 + 145 + 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 74 + 66 + 1354 + 385); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 74 + 66 + 1354 + 385);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1 + 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1 + 1 + 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 8); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 8);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
// C2S FIN Packet // C2S FIN Packet
printf("\n=> Packet Parse: TCP C2S FIN packet\n"); printf("\n=> Packet Parse: TCP C2S FIN packet\n");
@@ -325,16 +325,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 66 + 145 + 66 + 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 66 + 145 + 66 + 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 74 + 66 + 1354 + 385); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 74 + 66 + 1354 + 385);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1 + 1 + 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1 + 1 + 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 9); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 9);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
// S2C FIN Packet // S2C FIN Packet
printf("\n=> Packet Parse: TCP S2C FIN packet\n"); printf("\n=> Packet Parse: TCP S2C FIN packet\n");
@@ -356,16 +356,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 66 + 145 + 66 + 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 66 + 145 + 66 + 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 74 + 66 + 1354 + 385 + 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 74 + 66 + 1354 + 385 + 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1 + 1 + 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1 + 1 + 1 + 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 10); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 10);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
// C2S ACK Packet // C2S ACK Packet
printf("\n=> Packet Parse: TCP C2S ACK packet\n"); printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -387,16 +387,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 66 + 145 + 66 + 66 + 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 66 + 145 + 66 + 66 + 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 74 + 66 + 1354 + 385 + 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 74 + 66 + 1354 + 385 + 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1 + 1 + 1 + 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1 + 1 + 1 + 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 11); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 11);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
// check stat // check stat
session_manager_print_stat(mgr); session_manager_print_stat(mgr);

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

@@ -91,16 +91,16 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 145); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 145);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) == NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) == NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -181,16 +181,16 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 74 + 1354); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 74 + 1354);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) == NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) == NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat

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

@@ -103,16 +103,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 3); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 3);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -199,16 +199,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) == NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) == NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -295,16 +295,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -442,16 +442,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 74); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 74);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -543,16 +543,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 74); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 74);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 3); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 3);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -633,16 +633,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78 + 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78 + 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1 + 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1 + 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) == NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) == NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -722,16 +722,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 78); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 78);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 66); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 66);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat

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

@@ -76,16 +76,16 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_UDP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_UDP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 74); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 74);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 1);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) == NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) == NULL);
// S2C RESP Packet // S2C RESP Packet
printf("\n=> Packet Parse: UDP S2C RESP packet\n"); printf("\n=> Packet Parse: UDP S2C RESP packet\n");
@@ -106,16 +106,16 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_UDP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_UDP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 74); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 74);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 550); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 550);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 2);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat

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

@@ -81,16 +81,16 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_UDP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_UDP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 74); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 74);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 1);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_C2S);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) != NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) == NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) == NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat
@@ -161,16 +161,16 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_UDP); EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_UDP);
EXPECT_TRUE(session_has_dup_traffic(sess) == 0); EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0); EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_BYTES) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_BYTES_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_BYTES) == 550); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_BYTES_RX) == 550);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_C2S_PACKETS) == 0); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_C2S, STAT_RAW_PKTS_RX) == 0);
EXPECT_TRUE(session_get_metric(sess, SESSION_METRIC_S2C_PACKETS) == 1); EXPECT_TRUE(session_get_stat(sess, SESSION_DIR_S2C, STAT_RAW_PKTS_RX) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_NEW) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 1); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) == 1);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_CURRENT) == &pkt); EXPECT_TRUE(session_get_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C); EXPECT_TRUE(session_get_current_dir(sess) == SESSION_DIR_S2C);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_C2S_1ST) == NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_C2S) == NULL);
EXPECT_TRUE(session_get_packet(sess, SESSION_PACKET_S2C_1ST) != NULL); EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIR_S2C) != NULL);
session_dump(sess); session_dump(sess);
// check stat // check stat

65
src/stellar/stellar.cpp
View File

@@ -103,8 +103,6 @@ void plugin_manager_dispatch(void *plugin_mgr, struct session *sess, const struc
session_free_tcp_segment(sess, seg); session_free_tcp_segment(sess, seg);
} while (1); } while (1);
} }
session_clean_packet(sess, SESSION_PACKET_CURRENT);
session_set_cur_dir(sess, SESSION_DIR_NONE);
printf("<= plugin dispatch session\n"); printf("<= plugin dispatch session\n");
} }
@@ -139,6 +137,42 @@ static void signal_handler(int signo)
} }
} }
static void execute_packet_action(struct packet_io *packet_io, struct session *sess, struct packet *pkt, uint16_t thr_idx)
{
enum packet_action action = packet_get_action(pkt);
enum packet_type type = packet_get_type(pkt);
if (sess)
{
enum session_stat stat_pkt;
enum session_stat stat_byte;
if (action == PACKET_ACTION_DROP)
{
stat_pkt = (type == PACKET_TYPE_CTRL) ? STAT_CTRL_PKTS_DROP : STAT_RAW_PKTS_DROP;
stat_byte = (type == PACKET_TYPE_CTRL) ? STAT_CTRL_BYTES_DROP : STAT_RAW_BYTES_DROP;
}
else
{
stat_pkt = (type == PACKET_TYPE_CTRL) ? STAT_CTRL_PKTS_TX : STAT_RAW_PKTS_TX;
stat_byte = (type == PACKET_TYPE_CTRL) ? STAT_CTRL_BYTES_TX : STAT_RAW_BYTES_TX;
}
session_inc_stat(sess, session_get_current_dir(sess), stat_pkt, 1);
session_inc_stat(sess, session_get_current_dir(sess), stat_byte, packet_get_len(pkt));
session_set_current_packet(sess, NULL);
session_set_current_dir(sess, SESSION_DIR_NONE);
}
if (action == PACKET_ACTION_DROP)
{
packet_io_drop(packet_io, thr_idx, pkt, 1);
}
else
{
packet_io_egress(packet_io, thr_idx, pkt, 1);
}
}
/****************************************************************************** /******************************************************************************
* thread * thread
******************************************************************************/ ******************************************************************************/
@@ -165,7 +199,6 @@ static void *main_loop(void *arg)
void *plug_mgr_ctx = NULL; void *plug_mgr_ctx = NULL;
int nr_recv; int nr_recv;
int need_drop_pkt = 1; // TODO
uint64_t now = 0; uint64_t now = 0;
uint16_t thr_idx = threads_ctx->index; uint16_t thr_idx = threads_ctx->index;
@@ -198,7 +231,7 @@ static void *main_loop(void *arg)
struct packet *defraged_pkt = ip_reassembly_packet(ip_reass, pkt, now); struct packet *defraged_pkt = ip_reassembly_packet(ip_reass, pkt, now);
if (defraged_pkt == NULL) if (defraged_pkt == NULL)
{ {
continue; goto fast_path;
} }
else else
{ {
@@ -207,15 +240,13 @@ static void *main_loop(void *arg)
} }
} }
// TODO filter protocol before session lookup
sess = session_manager_lookup_session(sess_mgr, pkt); sess = session_manager_lookup_session(sess_mgr, pkt);
if (sess == NULL) if (sess == NULL)
{ {
sess = session_manager_new_session(sess_mgr, pkt, now); sess = session_manager_new_session(sess_mgr, pkt, now);
if (sess == NULL) if (sess == NULL)
{ {
continue; goto fast_path;
} }
plug_mgr_ctx = plugin_manager_new_ctx(); plug_mgr_ctx = plugin_manager_new_ctx();
session_set_user_data(sess, plug_mgr_ctx); session_set_user_data(sess, plug_mgr_ctx);
@@ -225,25 +256,9 @@ static void *main_loop(void *arg)
session_manager_update_session(sess_mgr, sess, pkt, now); session_manager_update_session(sess_mgr, sess, pkt, now);
} }
plugin_manager_dispatch(plug_mgr, sess, pkt); plugin_manager_dispatch(plug_mgr, sess, pkt);
}
if (unlikely(need_drop_pkt)) fast_path:
{ execute_packet_action(packet_io, sess, pkt, thr_idx);
for (int i = 0; i < nr_recv; i++)
{
if (packet_get_action(&packets[i]) == PACKET_ACTION_DROP)
{
packet_io_drop(packet_io, thr_idx, &packets[i], 1);
}
else
{
packet_io_egress(packet_io, thr_idx, &packets[i], 1);
}
}
}
else
{
packet_io_egress(packet_io, thr_idx, packets, nr_recv);
} }
idle_tasks: idle_tasks: